libraries/mobiledatadownload/DownloadFileTest.java

/*
 * Copyright 2022 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.android.libraries.mobiledatadownload;

import static com.google.android.libraries.mobiledatadownload.DownloadException.DownloadResultCode.ANDROID_DOWNLOADER_UNKNOWN;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import android.content.Context;
import android.net.Uri;
import android.util.Log;
import androidx.test.core.app.ApplicationProvider;
import com.google.android.libraries.mobiledatadownload.downloader.DownloadConstraints;
import com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest;
import com.google.android.libraries.mobiledatadownload.downloader.FileDownloader;
import com.google.android.libraries.mobiledatadownload.file.SynchronousFileStorage;
import com.google.android.libraries.mobiledatadownload.file.backends.AndroidFileBackend;
import com.google.android.libraries.mobiledatadownload.foreground.ForegroundDownloadKey;
import com.google.android.libraries.mobiledatadownload.internal.logging.LogUtil;
import com.google.android.libraries.mobiledatadownload.monitor.DownloadProgressMonitor;
import com.google.android.libraries.mobiledatadownload.monitor.NetworkUsageMonitor;
import com.google.android.libraries.mobiledatadownload.testing.BlockingFileDownloader;
import com.google.android.libraries.mobiledatadownload.testing.FakeTimeSource;
import com.google.android.libraries.mobiledatadownload.testing.TestFlags;
import com.google.common.base.Optional;
import com.google.common.base.Supplier;
import com.google.common.base.Suppliers;
import com.google.common.collect.ImmutableList;
import com.google.common.labs.concurrent.LabsFutures;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnit;
import org.mockito.junit.MockitoRule;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.shadows.ShadowLog;

@RunWith(RobolectricTestRunner.class)
public final class DownloadFileTest {
  @Rule public final MockitoRule mocks = MockitoJUnit.rule();

  // 1MB file.
  private static final String FILE_URL =
      "https://www.gstatic.com/icing/idd/sample_group/sample_file_3_1519240701";
  private static final Uri DESTINATION_FILE_URI =
      Uri.parse(
          "android://com.google.android.libraries.mobiledatadownload/files/datadownload/shared/public/file_1");

  private static final Context context = ApplicationProvider.getApplicationContext();

  private final TestFlags flags = new TestFlags();
  private final FakeTimeSource clock = new FakeTimeSource();

  private DownloadProgressMonitor downloadProgressMonitor;
  private SynchronousFileStorage fileStorage;

  @Mock private SingleFileDownloadListener mockDownloadListener;
  @Mock private NetworkUsageMonitor mockNetworkUsageMonitor;
  @Mock private FileDownloader mockFileDownloader;
  @Mock private DownloadProgressMonitor mockDownloadMonitor;

  private BlockingFileDownloader blockingFileDownloader;
  private SingleFileDownloadRequest singleFileDownloadRequest;
  private MobileDataDownload mobileDataDownload;

  @Captor ArgumentCaptor<DownloadListener> downloadListenerCaptor;

  @Captor
  ArgumentCaptor<com.google.android.libraries.mobiledatadownload.lite.DownloadListener>
      liteDownloadListenerCaptor;

  @Captor ArgumentCaptor<DownloadRequest> singleFileDownloadRequestCaptor;

  ListeningExecutorService controlExecutor =
      MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());

  @Before
  public void setUp() {
    ShadowLog.setLoggable(LogUtil.TAG, Log.DEBUG);

    downloadProgressMonitor = new DownloadProgressMonitor(clock, controlExecutor);

    fileStorage =
        new SynchronousFileStorage(
            /* backends= */ ImmutableList.of(AndroidFileBackend.builder(context).build()),
            /* transforms= */ ImmutableList.of(),
            /* monitors= */ ImmutableList.of(downloadProgressMonitor));

    singleFileDownloadRequest =
        SingleFileDownloadRequest.newBuilder()
            .setDestinationFileUri(DESTINATION_FILE_URI)
            .setUrlToDownload(FILE_URL)
            .setDownloadConstraints(DownloadConstraints.NETWORK_CONNECTED)
            .setNotificationContentTitle("File url: " + FILE_URL)
            .build();

    blockingFileDownloader = new BlockingFileDownloader(controlExecutor);

    when(mockDownloadListener.onComplete()).thenReturn(Futures.immediateVoidFuture());
    when(mockFileDownloader.startDownloading(singleFileDownloadRequestCaptor.capture()))
        .thenReturn(Futures.immediateVoidFuture());
  }

  @After
  public void tearDown() {
    // Reset state of blockingFileDownloader to prevent deadlocks
    blockingFileDownloader.resetState();
  }

  @Test
  public void downloadFile_whenRequestAlreadyMade_dedups() throws Exception {
    // Use BlockingFileDownloader to ensure first download is in progress.
    mobileDataDownload = getMobileDataDownload(() -> blockingFileDownloader);

    ListenableFuture<Void> downloadFuture1 =
        mobileDataDownload.downloadFile(singleFileDownloadRequest);
    ListenableFuture<Void> downloadFuture2 =
        mobileDataDownload.downloadFile(singleFileDownloadRequest);

    // Allow blocking download to finish
    blockingFileDownloader.finishDownloading();

    // Finish future 2 and assert that future 1 has completed as well
    downloadFuture2.get();

    awaitAllExecutorsIdle();

    assertThat(downloadFuture1.isDone()).isTrue();
  }

  @Test
  public void downloadFile_whenRequestAlreadyMadeUsingForegroundService_dedups() throws Exception {
    // Use BlockingFileDownloader to ensure first download is in progress.
    mobileDataDownload = getMobileDataDownload(() -> blockingFileDownloader);

    ListenableFuture<Void> downloadFuture1 =
        mobileDataDownload.downloadFileWithForegroundService(singleFileDownloadRequest);
    ListenableFuture<Void> downloadFuture2 =
        mobileDataDownload.downloadFile(singleFileDownloadRequest);

    // Allow blocking download to finish
    blockingFileDownloader.finishDownloading();

    // Finish future 2 and assert that future 1 has completed as well
    downloadFuture2.get();

    awaitAllExecutorsIdle();
    assertThat(downloadFuture1.isDone()).isTrue();
  }

  @Test
  public void downloadFile_beginsDownload() throws Exception {
    mobileDataDownload =
        getMobileDataDownload(
            () -> mockFileDownloader,
            /* foregroundDownloadServiceClassOptional= */ Optional.absent(),
            Optional.of(mockDownloadMonitor));

    singleFileDownloadRequest =
        SingleFileDownloadRequest.newBuilder()
            .setDestinationFileUri(DESTINATION_FILE_URI)
            .setUrlToDownload(FILE_URL)
            .setDownloadConstraints(DownloadConstraints.NETWORK_CONNECTED)
            .setListenerOptional(Optional.of(mockDownloadListener))
            .build();

    ListenableFuture<Void> downloadFuture =
        mobileDataDownload.downloadFile(singleFileDownloadRequest);
    downloadFuture.get();

    awaitAllExecutorsIdle();

    // Verify that correct DownloadRequest is sent to underlying FileDownloader
    DownloadRequest actualDownloadRequest = singleFileDownloadRequestCaptor.getValue();
    assertThat(actualDownloadRequest.fileUri()).isEqualTo(DESTINATION_FILE_URI);
    assertThat(actualDownloadRequest.urlToDownload()).isEqualTo(FILE_URL);
    assertThat(actualDownloadRequest.downloadConstraints())
        .isEqualTo(DownloadConstraints.NETWORK_CONNECTED);

    // Verify that downloadMonitor adds the listener
    verify(mockDownloadMonitor).addDownloadListener(any(), liteDownloadListenerCaptor.capture());
    verify(mockFileDownloader).startDownloading(any());

    verify(mockDownloadMonitor).removeDownloadListener(DESTINATION_FILE_URI);
    verify(mockDownloadListener).onComplete();

    // Ensure that given download listener is the same one passed to download monitor
    com.google.android.libraries.mobiledatadownload.lite.DownloadListener capturedDownloadListener =
        liteDownloadListenerCaptor.getValue();
    DownloadException testException =
        DownloadException.builder().setDownloadResultCode(ANDROID_DOWNLOADER_UNKNOWN).build();

    capturedDownloadListener.onProgress(10);
    capturedDownloadListener.onFailure(testException);
    capturedDownloadListener.onPausedForConnectivity();

    verify(mockDownloadListener).onProgress(10);
    verify(mockDownloadListener).onFailure(testException);
    verify(mockDownloadListener).onPausedForConnectivity();
  }

  @Test
  public void download_whenListenerProvided_handlesOnCompleteFailed() throws Exception {
    Exception failureException = new Exception("test failure");
    when(mockDownloadListener.onComplete())
        .thenReturn(Futures.immediateFailedFuture(failureException));
    mobileDataDownload =
        getMobileDataDownload(
            createSuccessfulFileDownloaderSupplier(),
            /* foregroundDownloadServiceClassOptional= */ Optional.absent(),
            Optional.of(downloadProgressMonitor));

    singleFileDownloadRequest =
        SingleFileDownloadRequest.newBuilder()
            .setDestinationFileUri(DESTINATION_FILE_URI)
            .setUrlToDownload(FILE_URL)
            .setDownloadConstraints(DownloadConstraints.NETWORK_CONNECTED)
            .setListenerOptional(Optional.of(mockDownloadListener))
            .build();

    mobileDataDownload.downloadFile(singleFileDownloadRequest).get();

    awaitAllExecutorsIdle();

    // Verify the DownloadListeners onComplete was invoked
    verify(mockDownloadListener).onComplete();
  }

  @Test
  public void downloadFile_whenDownloadFails_reportsFailure() throws Exception {
    DownloadException downloadException =
        DownloadException.builder().setDownloadResultCode(ANDROID_DOWNLOADER_UNKNOWN).build();

    mobileDataDownload =
        getMobileDataDownload(
            createFailingFileDownloaderSupplier(downloadException),
            /* foregroundDownloadServiceClassOptional= */ Optional.absent(),
            Optional.of(downloadProgressMonitor));

    singleFileDownloadRequest =
        SingleFileDownloadRequest.newBuilder()
            .setDestinationFileUri(DESTINATION_FILE_URI)
            .setUrlToDownload(FILE_URL)
            .setDownloadConstraints(DownloadConstraints.NETWORK_CONNECTED)
            .setListenerOptional(Optional.of(mockDownloadListener))
            .build();

    ListenableFuture<Void> downloadFuture =
        mobileDataDownload.downloadFile(singleFileDownloadRequest);
    assertThrows(ExecutionException.class, downloadFuture::get);
    DownloadException e = LabsFutures.getFailureCauseAs(downloadFuture, DownloadException.class);
    assertThat(e.getDownloadResultCode()).isEqualTo(ANDROID_DOWNLOADER_UNKNOWN);

    // Verify that DownloadListener.onFailure was invoked with failure
    verify(mockDownloadListener).onFailure(downloadException);
    verify(mockDownloadListener, times(0)).onComplete();
  }

  @Test
  public void downloadFile_whenReturnedFutureIsCanceled_cancelsDownload() throws Exception {
    // Wrap mock around BlockingFileDownloader to simulate long download
    mobileDataDownload = getMobileDataDownload(() -> blockingFileDownloader);

    ListenableFuture<Void> downloadFuture =
        mobileDataDownload.downloadFile(singleFileDownloadRequest);

    // Wait for download to start and confirm download future is still running.
    blockingFileDownloader.waitForDownloadStarted();
    assertThat(downloadFuture.isDone()).isFalse();

    // Cancel download future.
    downloadFuture.cancel(true);

    // Check that future is now cancelled.
    assertThat(downloadFuture.isCancelled()).isTrue();
  }

  @Test
  public void downloadFile_whenMonitorNotProvided_whenDownloadFails_reportsFailure()
      throws Exception {
    DownloadException downloadException =
        DownloadException.builder().setDownloadResultCode(ANDROID_DOWNLOADER_UNKNOWN).build();

    mobileDataDownload =
        getMobileDataDownload(createFailingFileDownloaderSupplier(downloadException));

    singleFileDownloadRequest =
        SingleFileDownloadRequest.newBuilder()
            .setDestinationFileUri(DESTINATION_FILE_URI)
            .setUrlToDownload(FILE_URL)
            .setDownloadConstraints(DownloadConstraints.NETWORK_CONNECTED)
            .setListenerOptional(Optional.of(mockDownloadListener))
            .build();

    ListenableFuture<Void> downloadFuture =
        mobileDataDownload.downloadFile(singleFileDownloadRequest);
    assertThrows(ExecutionException.class, downloadFuture::get);
    DownloadException e = LabsFutures.getFailureCauseAs(downloadFuture, DownloadException.class);
    assertThat(e.getDownloadResultCode()).isEqualTo(ANDROID_DOWNLOADER_UNKNOWN);

    // Verify that DownloadListener.onFailure was invoked with failure
    verify(mockDownloadListener).onFailure(downloadException);
    verify(mockDownloadListener, times(0)).onComplete();
  }

  @Test
  public void downloadFileWithWithForegroundService_requiresForegroundDownloadService()
      throws Exception {
    // Create downloader without providing foreground service
    mobileDataDownload =
        getMobileDataDownload(
            () -> mockFileDownloader,
            /* foregroundDownloadServiceClassOptional= */ Optional.absent(),
            Optional.of(downloadProgressMonitor));

    // Without foreground service, download call should fail with IllegalStateException
    ListenableFuture<Void> downloadFuture =
        mobileDataDownload.downloadFileWithForegroundService(singleFileDownloadRequest);
    ExecutionException e = assertThrows(ExecutionException.class, downloadFuture::get);
    assertThat(e).hasCauseThat().isInstanceOf(IllegalStateException.class);

    // Verify that underlying download is not started
    verify(mockFileDownloader, times(0)).startDownloading(any());
  }

  @Test
  public void downloadFileWithForegroundService_requiresDownloadMonitor() throws Exception {
    // Create downloader without providing DownloadMonitor
    mobileDataDownload =
        getMobileDataDownload(
            () -> mockFileDownloader,
            Optional.of(this.getClass()),
            /* downloadProgressMonitorOptional= */ Optional.absent());

    // Without monitor, download call should fail with IllegalStateException
    ListenableFuture<Void> downloadFuture =
        mobileDataDownload.downloadFileWithForegroundService(singleFileDownloadRequest);
    ExecutionException e = assertThrows(ExecutionException.class, downloadFuture::get);
    assertThat(e).hasCauseThat().isInstanceOf(IllegalStateException.class);

    // Verify that underlying download is not started
    verify(mockFileDownloader, times(0)).startDownloading(any());
  }

  @Test
  public void downloadFileWithForegroundService_whenRequestAlreadyMade_dedups() throws Exception {
    // Use BlockingFileDownloader to control when the download will finish.
    mobileDataDownload = getMobileDataDownload(() -> blockingFileDownloader);

    ListenableFuture<Void> downloadFuture1 =
        mobileDataDownload.downloadFileWithForegroundService(singleFileDownloadRequest);
    ListenableFuture<Void> downloadFuture2 =
        mobileDataDownload.downloadFileWithForegroundService(singleFileDownloadRequest);

    // Now we let the 2 futures downloadFuture1 downloadFuture2 to run by opening the latch.
    blockingFileDownloader.finishDownloading();

    // Now finish future 2, future 1 should finish too and the cache clears the future.
    downloadFuture2.get();

    awaitAllExecutorsIdle();

    assertThat(downloadFuture1.isDone()).isTrue();
  }

  @Test
  public void
      downloadFileWithForegroundService_whenRequestAlreadyMadeWithoutForegroundService_dedups()
          throws Exception {
    // Use BlockingFileDownloader to control when the download will finish.
    mobileDataDownload =
        getMobileDataDownload(
            () -> blockingFileDownloader,
            Optional.of(this.getClass()),
            Optional.of(downloadProgressMonitor));

    ListenableFuture<Void> downloadFuture1 =
        mobileDataDownload.downloadFile(singleFileDownloadRequest);
    ListenableFuture<Void> downloadFuture2 =
        mobileDataDownload.downloadFileWithForegroundService(singleFileDownloadRequest);

    // Now we let the 2 futures downloadFuture1 downloadFuture2 to run by opening the latch.
    blockingFileDownloader.finishDownloading();

    // Now finish future 2, future 1 should finish too and the cache clears the future.
    downloadFuture2.get();

    awaitAllExecutorsIdle();

    assertThat(downloadFuture1.isDone()).isTrue();
  }

  @Test
  public void downloadFileWithForegroundService() throws Exception {
    when(mockFileDownloader.startDownloading(singleFileDownloadRequestCaptor.capture()))
        .thenReturn(Futures.immediateVoidFuture());
    mobileDataDownload =
        getMobileDataDownload(
            () -> mockFileDownloader,
            Optional.of(this.getClass()),
            Optional.of(mockDownloadMonitor));

    singleFileDownloadRequest =
        SingleFileDownloadRequest.newBuilder()
            .setDestinationFileUri(DESTINATION_FILE_URI)
            .setUrlToDownload(FILE_URL)
            .setDownloadConstraints(DownloadConstraints.NETWORK_CONNECTED)
            .setNotificationContentTitle("File url: " + FILE_URL)
            .setListenerOptional(Optional.of(mockDownloadListener))
            .build();

    ListenableFuture<Void> downloadFuture =
        mobileDataDownload.downloadFileWithForegroundService(singleFileDownloadRequest);
    downloadFuture.get();

    awaitAllExecutorsIdle();

    // Verify that the correct DownloadRequest is sent to underderlying FileDownloader.
    DownloadRequest actualDownloadRequest = singleFileDownloadRequestCaptor.getValue();
    assertThat(actualDownloadRequest.fileUri()).isEqualTo(DESTINATION_FILE_URI);
    assertThat(actualDownloadRequest.urlToDownload()).isEqualTo(FILE_URL);
    assertThat(actualDownloadRequest.downloadConstraints())
        .isEqualTo(DownloadConstraints.NETWORK_CONNECTED);

    // Verify that downloadMonitor will add a DownloadListener.
    verify(mockDownloadMonitor).addDownloadListener(any(), liteDownloadListenerCaptor.capture());
    verify(mockFileDownloader).startDownloading(any());

    verify(mockDownloadMonitor).removeDownloadListener(DESTINATION_FILE_URI);

    verify(mockDownloadListener).onComplete();

    com.google.android.libraries.mobiledatadownload.lite.DownloadListener capturedListener =
        liteDownloadListenerCaptor.getValue();

    // Now simulate other DownloadListener's callbacks:
    capturedListener.onProgress(10);
    capturedListener.onPausedForConnectivity();
    DownloadException downloadException =
        DownloadException.builder().setDownloadResultCode(ANDROID_DOWNLOADER_UNKNOWN).build();
    capturedListener.onFailure(downloadException);

    awaitAllExecutorsIdle();

    verify(mockDownloadListener).onProgress(10);
    verify(mockDownloadListener).onPausedForConnectivity();
    verify(mockDownloadListener).onFailure(downloadException);
  }

  @Test
  public void downloadFileWithForegroundService_clientOnCompleteFailed() throws Exception {
    Exception failureException = new Exception("test failure");

    when(mockFileDownloader.startDownloading(singleFileDownloadRequestCaptor.capture()))
        .thenReturn(Futures.immediateVoidFuture());
    mobileDataDownload =
        getMobileDataDownload(
            () -> mockFileDownloader,
            Optional.of(this.getClass()),
            Optional.of(downloadProgressMonitor));

    // Client's provided DownloadListener.onComplete failed.
    when(mockDownloadListener.onComplete())
        .thenReturn(Futures.immediateFailedFuture(failureException));

    singleFileDownloadRequest =
        SingleFileDownloadRequest.newBuilder()
            .setDestinationFileUri(DESTINATION_FILE_URI)
            .setUrlToDownload(FILE_URL)
            .setDownloadConstraints(DownloadConstraints.NETWORK_CONNECTED)
            .setNotificationContentTitle("File url: " + FILE_URL)
            .setListenerOptional(Optional.of(mockDownloadListener))
            .build();

    ListenableFuture<Void> downloadFuture =
        mobileDataDownload.downloadFileWithForegroundService(singleFileDownloadRequest);
    downloadFuture.get();

    awaitAllExecutorsIdle();

    // Verify that the correct DownloadRequest is sent to underderlying FileDownloader.
    DownloadRequest actualDownloadRequest = singleFileDownloadRequestCaptor.getValue();
    assertThat(actualDownloadRequest.fileUri()).isEqualTo(DESTINATION_FILE_URI);
    assertThat(actualDownloadRequest.urlToDownload()).isEqualTo(FILE_URL);
    assertThat(actualDownloadRequest.downloadConstraints())
        .isEqualTo(DownloadConstraints.NETWORK_CONNECTED);

    verify(mockFileDownloader).startDownloading(any());
    verify(mockDownloadListener).onComplete();
  }

  @Test
  public void downloadFileWithForegroundService_failure() throws Exception {
    DownloadException downloadException =
        DownloadException.builder().setDownloadResultCode(ANDROID_DOWNLOADER_UNKNOWN).build();

    when(mockFileDownloader.startDownloading(singleFileDownloadRequestCaptor.capture()))
        .thenReturn(Futures.immediateFailedFuture(downloadException));

    mobileDataDownload =
        getMobileDataDownload(
            () -> mockFileDownloader,
            Optional.of(this.getClass()),
            Optional.of(downloadProgressMonitor));

    singleFileDownloadRequest =
        SingleFileDownloadRequest.newBuilder()
            .setDestinationFileUri(DESTINATION_FILE_URI)
            .setUrlToDownload(FILE_URL)
            .setDownloadConstraints(DownloadConstraints.NETWORK_CONNECTED)
            .setNotificationContentTitle("File url: " + FILE_URL)
            .setListenerOptional(Optional.of(mockDownloadListener))
            .build();

    ListenableFuture<Void> downloadFuture =
        mobileDataDownload.downloadFileWithForegroundService(singleFileDownloadRequest);
    assertThrows(ExecutionException.class, downloadFuture::get);
    DownloadException e = LabsFutures.getFailureCauseAs(downloadFuture, DownloadException.class);
    assertThat(e.getDownloadResultCode()).isEqualTo(ANDROID_DOWNLOADER_UNKNOWN);

    awaitAllExecutorsIdle();

    // Verify that the correct DownloadRequest is sent to underderlying FileDownloader.
    DownloadRequest actualDownloadRequest = singleFileDownloadRequestCaptor.getValue();
    assertThat(actualDownloadRequest.fileUri()).isEqualTo(DESTINATION_FILE_URI);
    assertThat(actualDownloadRequest.urlToDownload()).isEqualTo(FILE_URL);
    assertThat(actualDownloadRequest.downloadConstraints())
        .isEqualTo(DownloadConstraints.NETWORK_CONNECTED);

    // Since the download failed, onComplete will not be called but onFailure.
    verify(mockDownloadListener, times(0)).onComplete();
    verify(mockDownloadListener).onFailure(downloadException);
  }

  @Test
  public void cancelDownloadFileWithForegroundService() throws Exception {
    // Use BlockingFileDownloader to control when the download will finish.
    mobileDataDownload = getMobileDataDownload(() -> blockingFileDownloader);

    ForegroundDownloadKey foregroundDownloadKey =
        ForegroundDownloadKey.ofSingleFile(DESTINATION_FILE_URI);

    ListenableFuture<Void> downloadFuture =
        mobileDataDownload.downloadFileWithForegroundService(singleFileDownloadRequest);

    blockingFileDownloader.waitForDownloadStarted();

    mobileDataDownload.cancelForegroundDownload(foregroundDownloadKey.toString());

    awaitAllExecutorsIdle();

    assertTrue(downloadFuture.isCancelled());
  }

  @Test
  public void cancelListenableFuture() throws Exception {
    // Use BlockingFileDownloader to control when the download will finish.
    mobileDataDownload = getMobileDataDownload(() -> blockingFileDownloader);

    ListenableFuture<Void> downloadFuture =
        mobileDataDownload.downloadFileWithForegroundService(singleFileDownloadRequest);

    // Wait for download to start and confirm download future is still running.
    blockingFileDownloader.waitForDownloadStarted();
    assertThat(downloadFuture.isDone()).isFalse();

    // Cancel download future.
    downloadFuture.cancel(true);

    // Check that future is now cancelled.
    assertThat(downloadFuture.isCancelled()).isTrue();
  }

  private Supplier<FileDownloader> createFailingFileDownloaderSupplier(Throwable throwable) {
    return Suppliers.ofInstance(
        new FileDownloader() {
          @Override
          public ListenableFuture<Void> startDownloading(DownloadRequest request) {
            return Futures.immediateFailedFuture(throwable);
          }
        });
  }

  private Supplier<FileDownloader> createSuccessfulFileDownloaderSupplier() {
    return Suppliers.ofInstance(
        new FileDownloader() {
          @Override
          public ListenableFuture<Void> startDownloading(DownloadRequest request) {
            return Futures.immediateVoidFuture();
          }
        });
  }

  private MobileDataDownload getMobileDataDownload(
      Supplier<FileDownloader> fileDownloaderSupplier) {
    return getMobileDataDownload(
        fileDownloaderSupplier, Optional.of(this.getClass()), Optional.of(downloadProgressMonitor));
  }

  private MobileDataDownload getMobileDataDownload(
      Supplier<FileDownloader> fileDownloaderSupplier,
      Optional<Class<?>> foregroundDownloadServiceClassOptional,
      Optional<DownloadProgressMonitor> downloadProgressMonitorOptional) {
    return MobileDataDownloadBuilder.newBuilder()
        .setContext(context)
        .setControlExecutor(controlExecutor)
        .setFileDownloaderSupplier(fileDownloaderSupplier)
        .setFileStorage(fileStorage)
        .setDownloadMonitorOptional(downloadProgressMonitorOptional)
        .setNetworkUsageMonitor(mockNetworkUsageMonitor)
        .setForegroundDownloadServiceOptional(foregroundDownloadServiceClassOptional)
        .setFlagsOptional(Optional.of(flags))
        .build();
  }

  /** Waits long enough for async operations to finish running. */
  // TODO(b/217551873): investigate ways to make this more robust
  private static void awaitAllExecutorsIdle() throws Exception {
    Thread.sleep(/* millis= */ 100);
  }
}