/*
 * 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.TestFileGroupPopulator.FILE_CHECKSUM;
import static com.google.android.libraries.mobiledatadownload.TestFileGroupPopulator.FILE_GROUP_NAME;
import static com.google.android.libraries.mobiledatadownload.TestFileGroupPopulator.FILE_ID;
import static com.google.android.libraries.mobiledatadownload.TestFileGroupPopulator.FILE_SIZE;
import static com.google.android.libraries.mobiledatadownload.TestFileGroupPopulator.FILE_URL;
import static com.google.android.libraries.mobiledatadownload.testing.MddTestDependencies.DownloaderConfigurationType;
import static com.google.android.libraries.mobiledatadownload.testing.MddTestDependencies.ExecutorType;
import static com.google.common.truth.Truth.assertThat;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.junit.Assert.assertThrows;

import android.accounts.Account;
import android.content.Context;
import android.net.Uri;
import android.util.Log;
import androidx.test.core.app.ApplicationProvider;
import com.google.android.libraries.mobiledatadownload.account.AccountUtil;
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.file.backends.JavaFileBackend;
import com.google.android.libraries.mobiledatadownload.file.transforms.CompressTransform;
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.MddTestDependencies;
import com.google.android.libraries.mobiledatadownload.testing.TestFileDownloader;
import com.google.android.libraries.mobiledatadownload.testing.TestFlags;
import com.google.common.base.Optional;
import com.google.common.base.Supplier;
import com.google.common.collect.ImmutableList;
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.ListeningScheduledExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.mobiledatadownload.ClientConfigProto.ClientFile;
import com.google.mobiledatadownload.ClientConfigProto.ClientFileGroup;
import com.google.mobiledatadownload.DownloadConfigProto.DataFile;
import com.google.mobiledatadownload.DownloadConfigProto.DataFileGroup;
import com.google.mobiledatadownload.DownloadConfigProto.DownloadConditions.DeviceNetworkPolicy;
import com.google.mobiledatadownload.TransformProto;
import com.google.mobiledatadownload.TransformProto.Transform;
import com.google.mobiledatadownload.TransformProto.Transforms;
import com.google.testing.junit.testparameterinjector.TestParameter;
import com.google.testing.junit.testparameterinjector.TestParameterInjector;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnit;
import org.mockito.junit.MockitoRule;

/**
 * Integration Tests that relate to {@link MobileDataDownload#downloadFileGroup}.
 *
 * <p>NOTE: Any tests related to cancellation should be added to {@link
 * DownloadFileGroupCancellationIntegrationTest} instead.
 */
@RunWith(TestParameterInjector.class)
public class DownloadFileGroupIntegrationTest {

  private static final String TAG = "DownloadFileGroupIntegrationTest";
  private static final int MAX_DOWNLOAD_FILE_GROUP_WAIT_TIME_SECS = 60;
  private static final int MAX_MULTI_MDD_API_WAIT_TIME_SECS = 120;
  private static final long MAX_MDD_API_WAIT_TIME_SECS = 5L;

  private static final ListeningScheduledExecutorService DOWNLOAD_EXECUTOR =
      MoreExecutors.listeningDecorator(Executors.newScheduledThreadPool(4));

  private static final String FILE_GROUP_NAME_INSECURE_URL = "test-group-insecure-url";
  private static final String FILE_GROUP_NAME_MULTIPLE_FILES = "test-group-multiple-files";

  private static final String FILE_ID_1 = "test-file-1";
  private static final String FILE_ID_2 = "test-file-2";
  private static final String FILE_CHECKSUM_1 = "a1cba9d87b1440f41ce9e7da38c43e1f6bd7d5df";
  private static final String FILE_CHECKSUM_2 = "cb2459d9f1b508993aba36a5ffd942a7e0d49ed6";
  private static final String FILE_NOT_EXIST_URL =
      "https://www.gstatic.com/icing/idd/notexist/file.txt";

  private static final String TEST_DATA_RELATIVE_PATH =
      "third_party/java_src/android_libs/mobiledatadownload/javatests/com/google/android/libraries/mobiledatadownload/testdata/";

  private static final String TEST_DATA_URL = "https://test.url/full_file.txt";
  private static final String TEST_DATA_CHECKSUM = "0c4f1e55c4ec28d0305c5cfde8610b7e6e9f7d9a";
  private static final int TEST_DATA_BYTE_SIZE = 110;

  private static final String TEST_DATA_COMPRESS_URL = "https://test.url/full_file.zlib";
  private static final String TEST_DATA_COMPRESS_CHECKSUM =
      "cbffcf480fd52a3c6bf9d21206d36f0a714bb97a";
  private static final int TEST_DATA_COMPRESS_BYTE_SIZE = 92;

  private static final String VARIANT_1 = "test-variant-1";
  private static final String VARIANT_2 = "test-variant-2";

  private static final Account ACCOUNT_1 = AccountUtil.create("account-name-1", "account-type");
  private static final Account ACCOUNT_2 = AccountUtil.create("account-name-2", "account-type");

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

  @Mock private TaskScheduler mockTaskScheduler;
  @Mock private NetworkUsageMonitor mockNetworkUsageMonitor;
  @Mock private DownloadProgressMonitor mockDownloadProgressMonitor;

  private SynchronousFileStorage fileStorage;
  private ListeningExecutorService controlExecutor;

  private final TestFlags flags = new TestFlags();

  @Rule(order = 1)
  public final MockitoRule mocks = MockitoJUnit.rule();

  @TestParameter ExecutorType controlExecutorType;

  @Before
  public void setUp() throws Exception {

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

    controlExecutor = controlExecutorType.executor();
  }

  @Test
  public void downloadAndRead(
      @TestParameter DownloaderConfigurationType downloaderConfigurationType) throws Exception {
    Optional<String> instanceId = Optional.of(MddTestDependencies.randomInstanceId());
    TestFileGroupPopulator testFileGroupPopulator = new TestFileGroupPopulator(context);
    MobileDataDownload mobileDataDownload =
        builderForTest()
            .setInstanceIdOptional(instanceId)
            .setFileDownloaderSupplier(
                downloaderConfigurationType.fileDownloaderSupplier(
                    context,
                    controlExecutor,
                    DOWNLOAD_EXECUTOR,
                    fileStorage,
                    flags,
                    Optional.of(mockDownloadProgressMonitor),
                    instanceId))
            .addFileGroupPopulator(testFileGroupPopulator)
            .build();

    testFileGroupPopulator
        .refreshFileGroups(mobileDataDownload)
        .get(MAX_MDD_API_WAIT_TIME_SECS, SECONDS);

    mobileDataDownload
        .downloadFileGroup(
            DownloadFileGroupRequest.newBuilder()
                .setGroupName(FILE_GROUP_NAME)
                .setListenerOptional(
                    Optional.of(
                        new DownloadListener() {
                          @Override
                          public void onProgress(long currentSize) {
                            Log.i(TAG, "onProgress " + currentSize);
                          }

                          @Override
                          public void onComplete(ClientFileGroup clientFileGroup) {
                            Log.i(TAG, "onComplete " + clientFileGroup.getGroupName());
                          }
                        }))
                .build())
        .get(MAX_DOWNLOAD_FILE_GROUP_WAIT_TIME_SECS, SECONDS);

    ClientFileGroup clientFileGroup =
        mobileDataDownload
            .getFileGroup(GetFileGroupRequest.newBuilder().setGroupName(FILE_GROUP_NAME).build())
            .get(MAX_MDD_API_WAIT_TIME_SECS, SECONDS);

    assertThat(clientFileGroup).isNotNull();
    assertThat(clientFileGroup.getGroupName()).isEqualTo(FILE_GROUP_NAME);
    assertThat(clientFileGroup.getFileCount()).isEqualTo(1);

    ClientFile clientFile = clientFileGroup.getFileList().get(0);
    assertThat(clientFile.getFileId()).isEqualTo(FILE_ID);
    Uri androidUri = Uri.parse(clientFile.getFileUri());
    assertThat(fileStorage.fileSize(androidUri)).isEqualTo(FILE_SIZE);

    mobileDataDownload.clear().get(MAX_MDD_API_WAIT_TIME_SECS, SECONDS);

    switch (downloaderConfigurationType) {
      case V2_PLATFORM:
        // No-op
    }
  }

  @Test
  public void downloadFailed() throws Exception {
    // NOTE: The test failures here are not network stack dependent, so there's
    // no need to parameterize this test for different network stacks.
    Optional<String> instanceId = Optional.of(MddTestDependencies.randomInstanceId());
    MobileDataDownload mobileDataDownload =
        builderForTest()
            .setInstanceIdOptional(instanceId)
            .setFileDownloaderSupplier(
                DownloaderConfigurationType.V2_PLATFORM.fileDownloaderSupplier(
                    context,
                    controlExecutor,
                    DOWNLOAD_EXECUTOR,
                    fileStorage,
                    flags,
                    Optional.of(mockDownloadProgressMonitor),
                    instanceId))
            .build();

    // The data file group has a file with insecure url.
    DataFileGroup groupWithInsecureUrl =
        TestFileGroupPopulator.createDataFileGroup(
            FILE_GROUP_NAME_INSECURE_URL,
            context.getPackageName(),
            new String[] {FILE_ID},
            new int[] {FILE_SIZE},
            new String[] {FILE_CHECKSUM},
            // Make the url insecure. This would lead to download failure.
            new String[] {FILE_URL.replace("https", "http")},
            DeviceNetworkPolicy.DOWNLOAD_ON_ANY_NETWORK);

    // The data file group has a file with non-existent url, and a file with insecure url.
    DataFileGroup groupWithMultipleFiles =
        TestFileGroupPopulator.createDataFileGroup(
            FILE_GROUP_NAME_MULTIPLE_FILES,
            context.getPackageName(),
            new String[] {FILE_ID_1, FILE_ID_2},
            new int[] {FILE_SIZE, FILE_SIZE},
            new String[] {FILE_CHECKSUM_1, FILE_CHECKSUM_2},
            // The first file url doesn't exist and the second file url is insecure.
            new String[] {FILE_NOT_EXIST_URL, FILE_URL.replace("https", "http")},
            DeviceNetworkPolicy.DOWNLOAD_ON_ANY_NETWORK);

    assertThat(
            mobileDataDownload
                .addFileGroup(
                    AddFileGroupRequest.newBuilder().setDataFileGroup(groupWithInsecureUrl).build())
                .get(MAX_MDD_API_WAIT_TIME_SECS, SECONDS))
        .isTrue();

    assertThat(
            mobileDataDownload
                .addFileGroup(
                    AddFileGroupRequest.newBuilder()
                        .setDataFileGroup(groupWithMultipleFiles)
                        .build())
                .get(MAX_MDD_API_WAIT_TIME_SECS, SECONDS))
        .isTrue();

    ExecutionException exception =
        assertThrows(
            ExecutionException.class,
            () ->
                mobileDataDownload
                    .downloadFileGroup(
                        DownloadFileGroupRequest.newBuilder()
                            .setGroupName(FILE_GROUP_NAME_INSECURE_URL)
                            .build())
                    .get(MAX_DOWNLOAD_FILE_GROUP_WAIT_TIME_SECS, SECONDS));
    assertThat(exception).hasCauseThat().isInstanceOf(AggregateException.class);
    AggregateException cause = (AggregateException) exception.getCause();
    assertThat(cause).isNotNull();
    ImmutableList<Throwable> failures = cause.getFailures();
    assertThat(failures).hasSize(1);
    assertThat(failures.get(0)).isInstanceOf(DownloadException.class);
    assertThat(failures.get(0)).hasMessageThat().contains("INSECURE_URL_ERROR");

    ExecutionException exception2 =
        assertThrows(
            ExecutionException.class,
            () ->
                mobileDataDownload
                    .downloadFileGroup(
                        DownloadFileGroupRequest.newBuilder()
                            .setGroupName(FILE_GROUP_NAME_MULTIPLE_FILES)
                            .build())
                    .get(MAX_DOWNLOAD_FILE_GROUP_WAIT_TIME_SECS, SECONDS));
    assertThat(exception2).hasCauseThat().isInstanceOf(AggregateException.class);
    AggregateException cause2 = (AggregateException) exception2.getCause();
    assertThat(cause2).isNotNull();
    ImmutableList<Throwable> failures2 = cause2.getFailures();
    assertThat(failures2).hasSize(2);
    assertThat(failures2.get(0)).isInstanceOf(DownloadException.class);
    assertThat(failures2.get(0))
        .hasCauseThat()
        .hasMessageThat()
        .containsMatch("httpStatusCode=404");
    assertThat(failures2.get(1)).isInstanceOf(DownloadException.class);
    assertThat(failures2.get(1)).hasMessageThat().contains("INSECURE_URL_ERROR");

    AggregateException exception3 =
        assertThrows(
            AggregateException.class,
            () -> {
              try {
                ListenableFuture<ClientFileGroup> downloadFuture1 =
                    mobileDataDownload.downloadFileGroup(
                        DownloadFileGroupRequest.newBuilder()
                            .setGroupName(FILE_GROUP_NAME_MULTIPLE_FILES)
                            .build());
                ListenableFuture<ClientFileGroup> downloadFuture2 =
                    mobileDataDownload.downloadFileGroup(
                        DownloadFileGroupRequest.newBuilder()
                            .setGroupName(FILE_GROUP_NAME_INSECURE_URL)
                            .build());

                Futures.successfulAsList(downloadFuture1, downloadFuture2)
                    .get(MAX_DOWNLOAD_FILE_GROUP_WAIT_TIME_SECS, SECONDS);

                AggregateException.throwIfFailed(
                    ImmutableList.of(downloadFuture1, downloadFuture2),
                    "Expected download failures");
              } catch (ExecutionException e) {
                throw e;
              }
            });
    assertThat(exception3.getFailures()).hasSize(2);
  }

  @Test
  public void removePartialDownloadThenDownloadAgain(
      @TestParameter DownloaderConfigurationType downloaderConfigurationType) throws Exception {
    Optional<String> instanceId = Optional.of(MddTestDependencies.randomInstanceId());

    Supplier<FileDownloader> fileDownloaderSupplier =
        downloaderConfigurationType.fileDownloaderSupplier(
            context,
            controlExecutor,
            DOWNLOAD_EXECUTOR,
            fileStorage,
            flags,
            Optional.of(mockDownloadProgressMonitor),
            instanceId);
    BlockingFileDownloader blockingFileDownloader =
        new BlockingFileDownloader(DOWNLOAD_EXECUTOR, fileDownloaderSupplier.get());

    MobileDataDownload mobileDataDownload =
        builderForTest()
            .setInstanceIdOptional(instanceId)
            .setFileDownloaderSupplier(() -> blockingFileDownloader)
            .build();

    mobileDataDownload.clear().get(MAX_MDD_API_WAIT_TIME_SECS, SECONDS);

    // Add the filegroup, start downloading, then cancel while in progress.
    TestFileGroupPopulator testFileGroupPopulator = new TestFileGroupPopulator(context);
    testFileGroupPopulator
        .refreshFileGroups(mobileDataDownload)
        .get(MAX_MDD_API_WAIT_TIME_SECS, SECONDS);

    ListenableFuture<ClientFileGroup> downloadFuture =
        mobileDataDownload.downloadFileGroup(
            DownloadFileGroupRequest.newBuilder().setGroupName(FILE_GROUP_NAME).build());

    blockingFileDownloader.finishDownloading(); // Unblocks blockingFileDownloader
    blockingFileDownloader.waitForDelegateStarted(); // Waits until offroadDownloader starts

    // NOTE: add a little wait to allow Downloader's listeners to run.
    Thread.sleep(/* millis= */ 200);

    downloadFuture.cancel(true /* may interrupt */);

    // NOTE: add a little wait to allow Downloader's listeners to run.
    Thread.sleep(/* millis= */ 200);

    // Remove the filegroup.
    ListenableFuture<Boolean> removeFuture =
        mobileDataDownload.removeFileGroup(
            RemoveFileGroupRequest.newBuilder().setGroupName(FILE_GROUP_NAME).build());
    removeFuture.get(MAX_MDD_API_WAIT_TIME_SECS, SECONDS);

    // Add then try to download again.
    blockingFileDownloader.resetState();
    blockingFileDownloader.finishDownloading(); // Unblocks blockingFileDownloader

    testFileGroupPopulator
        .refreshFileGroups(mobileDataDownload)
        .get(MAX_MDD_API_WAIT_TIME_SECS, SECONDS);

    downloadFuture =
        mobileDataDownload.downloadFileGroup(
            DownloadFileGroupRequest.newBuilder().setGroupName(FILE_GROUP_NAME).build());

    downloadFuture.get(MAX_DOWNLOAD_FILE_GROUP_WAIT_TIME_SECS, SECONDS);

    // The file should have downloaded as expected.
    ClientFileGroup clientFileGroup =
        mobileDataDownload
            .getFileGroup(GetFileGroupRequest.newBuilder().setGroupName(FILE_GROUP_NAME).build())
            .get(MAX_MDD_API_WAIT_TIME_SECS, SECONDS);

    assertThat(clientFileGroup).isNotNull();
    assertThat(clientFileGroup.getFileCount()).isEqualTo(1);
    Uri androidUri = Uri.parse(clientFileGroup.getFileList().get(0).getFileUri());
    assertThat(fileStorage.fileSize(androidUri)).isEqualTo(FILE_SIZE);
  }

  @Test
  public void downloadDifferentGroupsWithSameFileTest() throws Exception {
    Optional<String> instanceId = Optional.of(MddTestDependencies.randomInstanceId());
    MobileDataDownload mobileDataDownload =
        builderForTest()
            .setInstanceIdOptional(instanceId)
            .setFileDownloaderSupplier(
                () ->
                    new TestFileDownloader(TEST_DATA_RELATIVE_PATH, fileStorage, DOWNLOAD_EXECUTOR))
            .build();

    DataFile.Builder dataFileBuilder =
        DataFile.newBuilder()
            .setUrlToDownload(TEST_DATA_URL)
            .setChecksum(TEST_DATA_CHECKSUM)
            .setByteSize(TEST_DATA_BYTE_SIZE);
    DataFileGroup.Builder groupBuilder = DataFileGroup.newBuilder();

    // Add all groups concurrently
    ArrayList<ListenableFuture<Boolean>> addFutures = new ArrayList<>();
    for (int i = 0; i < 50; i++) {
      String groupName = String.format("group%d", i);
      String fileId = String.format("group%d_file", i);

      DataFile file = dataFileBuilder.setFileId(fileId).build();
      DataFileGroup group =
          DataFileGroup.newBuilder().setGroupName(groupName).addFile(file).build();

      addFutures.add(
          mobileDataDownload.addFileGroup(
              AddFileGroupRequest.newBuilder().setDataFileGroup(group).build()));
    }
    Futures.allAsList(addFutures).get(MAX_MULTI_MDD_API_WAIT_TIME_SECS, SECONDS);

    // Start all downloads concurrently
    ArrayList<ListenableFuture<ClientFileGroup>> downloadFutures = new ArrayList<>();
    for (int i = 0; i < 50; i++) {
      String groupName = String.format("group%d", i);

      downloadFutures.add(
          mobileDataDownload.downloadFileGroup(
              DownloadFileGroupRequest.newBuilder().setGroupName(groupName).build()));
    }
    List<ClientFileGroup> groups =
        Futures.allAsList(downloadFutures).get(MAX_MULTI_MDD_API_WAIT_TIME_SECS, SECONDS);

    assertThat(groups).doesNotContain(null);
  }

  @Test
  public void concurrentDownloads_withSameFile_withDifferentDownloadTransforms_completes(
      @TestParameter boolean enableDedupByFileKey) throws Exception {
    flags.enableFileDownloadDedupByFileKey = Optional.of(enableDedupByFileKey);

    Optional<String> instanceId = Optional.of(MddTestDependencies.randomInstanceId());
    MobileDataDownload mobileDataDownload =
        builderForTest()
            .setInstanceIdOptional(instanceId)
            .setFileDownloaderSupplier(
                () ->
                    new TestFileDownloader(TEST_DATA_RELATIVE_PATH, fileStorage, DOWNLOAD_EXECUTOR))
            .build();

    // Create two groups which share the same file, but have different download transforms
    DataFileGroup groupWithoutTransform =
        DataFileGroup.newBuilder()
            .setGroupName("groupWithoutTransform")
            .addFile(
                DataFile.newBuilder()
                    .setFileId("file_no_transform")
                    .setUrlToDownload(TEST_DATA_URL)
                    .setChecksum(TEST_DATA_CHECKSUM)
                    .setByteSize(TEST_DATA_BYTE_SIZE))
            .build();

    DataFileGroup groupWithTransform =
        DataFileGroup.newBuilder()
            .setGroupName("groupWithTransform")
            .addFile(
                DataFile.newBuilder()
                    .setFileId("file_no_transform")
                    .setUrlToDownload(TEST_DATA_COMPRESS_URL)
                    .setChecksum(TEST_DATA_CHECKSUM)
                    .setByteSize(TEST_DATA_BYTE_SIZE)
                    .setDownloadedFileChecksum(TEST_DATA_COMPRESS_CHECKSUM)
                    .setDownloadedFileByteSize(TEST_DATA_COMPRESS_BYTE_SIZE)
                    .setDownloadTransforms(
                        Transforms.newBuilder()
                            .addTransform(
                                Transform.newBuilder()
                                    .setCompress(
                                        TransformProto.CompressTransform.getDefaultInstance())
                                    .build())
                            .build())
                    .build())
            .build();

    // Add both groups, then attempt to download both concurrently
    mobileDataDownload
        .addFileGroup(
            AddFileGroupRequest.newBuilder().setDataFileGroup(groupWithoutTransform).build())
        .get(MAX_MDD_API_WAIT_TIME_SECS, SECONDS);
    mobileDataDownload
        .addFileGroup(AddFileGroupRequest.newBuilder().setDataFileGroup(groupWithTransform).build())
        .get(MAX_MDD_API_WAIT_TIME_SECS, SECONDS);

    ListenableFuture<ClientFileGroup> downloadWithoutTransform =
        mobileDataDownload.downloadFileGroup(
            DownloadFileGroupRequest.newBuilder().setGroupName("groupWithoutTransform").build());
    ListenableFuture<ClientFileGroup> downloadWithTransform =
        mobileDataDownload.downloadFileGroup(
            DownloadFileGroupRequest.newBuilder().setGroupName("groupWithTransform").build());

    List<ClientFileGroup> downloadedGroups =
        Futures.allAsList(ImmutableList.of(downloadWithoutTransform, downloadWithTransform))
            .get(MAX_MULTI_MDD_API_WAIT_TIME_SECS, SECONDS);

    // Both groups are downloaded and both files point to the same on-device uri.
    assertThat(downloadedGroups).doesNotContain(null);
    assertThat(downloadedGroups.get(0).getFile(0).getFileUri())
        .isEqualTo(downloadedGroups.get(1).getFile(0).getFileUri());
  }

  /**
   * Returns MDD Builder with common dependencies set -- additional dependencies are added in each
   * test as needed.
   */
  private MobileDataDownloadBuilder builderForTest() {

    return MobileDataDownloadBuilder.newBuilder()
        .setContext(context)
        .setControlExecutor(controlExecutor)
        .setFileStorage(fileStorage)
        .setTaskScheduler(Optional.of(mockTaskScheduler))
        .setDeltaDecoderOptional(Optional.absent())
        .setNetworkUsageMonitor(mockNetworkUsageMonitor)
        .setDownloadMonitorOptional(Optional.of(mockDownloadProgressMonitor))
        .setFlagsOptional(Optional.of(flags));
  }
}