path: root/javatests/com/google/android/libraries/mobiledatadownload/ImportFilesIntegrationTest.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.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.common.truth.Truth.assertThat;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.fail;

import android.content.Context;
import android.net.Uri;
import android.os.Environment;
import androidx.test.core.app.ApplicationProvider;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import com.google.android.libraries.mobiledatadownload.DownloadException.DownloadResultCode;
import com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest;
import com.google.android.libraries.mobiledatadownload.downloader.FileDownloader;
import com.google.android.libraries.mobiledatadownload.downloader.MultiSchemeFileDownloader;
import com.google.android.libraries.mobiledatadownload.downloader.inline.InlineFileDownloader;
import com.google.android.libraries.mobiledatadownload.downloader.offroad.dagger.downloader2.BaseFileDownloaderModule;
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.FileUri;
import com.google.android.libraries.mobiledatadownload.file.backends.JavaFileBackend;
import com.google.android.libraries.mobiledatadownload.file.common.testing.FakeFileBackend;
import com.google.android.libraries.mobiledatadownload.file.common.testing.FakeFileBackend.OperationType;
import com.google.android.libraries.mobiledatadownload.file.integration.downloader.SharedPreferencesDownloadMetadata;
import com.google.android.libraries.mobiledatadownload.file.openers.ReadStreamOpener;
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.TestFlags;
import com.google.common.base.Optional;
import com.google.common.base.Supplier;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.truth.Correspondence;
import com.google.common.util.concurrent.FutureCallback;
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 com.google.mobiledatadownload.ClientConfigProto.ClientFile;
import com.google.mobiledatadownload.ClientConfigProto.ClientFileGroup;
import com.google.mobiledatadownload.ClientConfigProto.ClientFileGroup.Status;
import com.google.mobiledatadownload.DownloadConfigProto.DataFile;
import com.google.mobiledatadownload.DownloadConfigProto.DataFileGroup;
import com.google.protobuf.ByteString;
import java.io.IOException;
import java.io.InputStream;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.After;
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;

@RunWith(AndroidJUnit4.class)
public final class ImportFilesIntegrationTest {

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

  private static final String TAG = "ImportFilesIntegrationTest";

  private static final String TEST_DATA_ABSOLUTE_PATH =
      Environment.getExternalStorageDirectory()
          + "/googletest/test_runfiles/google3/third_party/java_src/android_libs/mobiledatadownload/javatests/com/google/android/libraries/mobiledatadownload/testdata/";

  // Note: Control Executor must not be a single thread executor.
  private static final ListeningExecutorService CONTROL_EXECUTOR =
      MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());
  private static final ScheduledExecutorService DOWNLOAD_EXECUTOR =
      Executors.newScheduledThreadPool(2);

  private static final String FILE_ID_1 = "test-file-1";
  private static final Uri FILE_URI_1 =
      Uri.parse(
          FileUri.builder().setPath(TEST_DATA_ABSOLUTE_PATH + "odws1_empty").build().toString());
  private static final String FILE_CHECKSUM_1 = "a1cba9d87b1440f41ce9e7da38c43e1f6bd7d5df";
  private static final String FILE_URL_1 = "inlinefile:sha1:" + FILE_CHECKSUM_1;
  private static final int FILE_SIZE_1 = 554;
  private static final DataFile INLINE_DATA_FILE_1 =
      DataFile.newBuilder()
          .setFileId(FILE_ID_1)
          .setByteSize(FILE_SIZE_1)
          .setUrlToDownload(FILE_URL_1)
          .setChecksum(FILE_CHECKSUM_1)
          .build();

  private static final String FILE_ID_2 = "test-file-2";
  private static final Uri FILE_URI_2 =
      Uri.parse(
          FileUri.builder()
              .setPath(TEST_DATA_ABSOLUTE_PATH + "zip_test_folder.zip")
              .build()
              .toString());
  private static final String FILE_CHECKSUM_2 = "7024b6bcddf2b2897656e9353f7fc715df5ea986";
  private static final String FILE_URL_2 = "inlinefile:sha2:" + FILE_CHECKSUM_2;
  private static final int FILE_SIZE_2 = 373;
  private static final DataFile INLINE_DATA_FILE_2 =
      DataFile.newBuilder()
          .setFileId(FILE_ID_2)
          .setByteSize(FILE_SIZE_2)
          .setUrlToDownload(FILE_URL_2)
          .setChecksum(FILE_CHECKSUM_2)
          .build();

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

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

  private FakeFileBackend fakeFileBackend;
  private SynchronousFileStorage fileStorage;
  private Supplier<FileDownloader> multiSchemeFileDownloaderSupplier;
  private MobileDataDownload mobileDataDownload;

  private FileSource inlineFileSource1;
  private FileSource inlineFileSource2;

  private final TestFlags flags = new TestFlags();

  @Before
  public void setUp() throws Exception {

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

    Supplier<FileDownloader> fileDownloaderSupplier =
        () ->
            BaseFileDownloaderModule.createOffroad2FileDownloader(
                context,
                DOWNLOAD_EXECUTOR,
                CONTROL_EXECUTOR,
                fileStorage,
                new SharedPreferencesDownloadMetadata(
                    context.getSharedPreferences("downloadmetadata", 0), CONTROL_EXECUTOR),
                Optional.of(mockDownloadProgressMonitor),
                /* urlEngineOptional= */ Optional.absent(),
                /* exceptionHandlerOptional= */ Optional.absent(),
                /* authTokenProviderOptional= */ Optional.absent(),
                /* trafficTag= */ Optional.absent(),
                flags);

    Supplier<FileDownloader> inlineFileDownloaderSupplier =
        () -> new InlineFileDownloader(fileStorage, DOWNLOAD_EXECUTOR);
    multiSchemeFileDownloaderSupplier =
        () ->
            MultiSchemeFileDownloader.builder()
                .addScheme("https", fileDownloaderSupplier.get())
                .addScheme("inlinefile", inlineFileDownloaderSupplier.get())
                .build();

    // Set up inline file sources
    try (InputStream fileStream1 = fileStorage.open(FILE_URI_1, ReadStreamOpener.create());
        InputStream fileStream2 = fileStorage.open(FILE_URI_2, ReadStreamOpener.create())) {
      inlineFileSource1 = FileSource.ofByteString(ByteString.readFrom(fileStream1));
      inlineFileSource2 = FileSource.ofByteString(ByteString.readFrom(fileStream2));
    }
  }

  @After
  public void tearDown() throws Exception {
    // Clear file group to ensure there is not cross-test pollination
    mobileDataDownload.clear().get();
    // Reset fake file backend
    fakeFileBackend.clearFailure(OperationType.ALL);
  }

  @Test
  public void importFiles_performsImport() throws Exception {
    createMobileDataDownload(multiSchemeFileDownloaderSupplier);

    DataFileGroup fileGroupWithInlineFile =
        DataFileGroup.newBuilder()
            .setGroupName(FILE_GROUP_NAME)
            .addFile(INLINE_DATA_FILE_1)
            .build();

    // Ensure that we add the file group successfully
    assertThat(
            mobileDataDownload
                .addFileGroup(
                    AddFileGroupRequest.newBuilder()
                        .setDataFileGroup(fileGroupWithInlineFile)
                        .build())
                .get())
        .isTrue();

    // Perform the import
    mobileDataDownload
        .importFiles(
            ImportFilesRequest.newBuilder()
                .setGroupName(FILE_GROUP_NAME)
                .setBuildId(fileGroupWithInlineFile.getBuildId())
                .setVariantId(fileGroupWithInlineFile.getVariantId())
                .setInlineFileMap(ImmutableMap.of(FILE_ID_1, inlineFileSource1))
                .build())
        .get();

    // Assert that the resulting group is downloaded and contains a reference to on device file
    ClientFileGroup importResult =
        mobileDataDownload
            .getFileGroup(GetFileGroupRequest.newBuilder().setGroupName(FILE_GROUP_NAME).build())
            .get();

    assertThat(importResult).isNotNull();
    assertThat(importResult.getGroupName()).isEqualTo(FILE_GROUP_NAME);
    assertThat(importResult.getFileCount()).isEqualTo(1);
    assertThat(importResult.getStatus()).isEqualTo(Status.DOWNLOADED);
    assertThat(importResult.getFile(0).getFileUri()).isNotEmpty();

    assertThat(fileStorage.exists(Uri.parse(importResult.getFile(0).getFileUri()))).isTrue();
  }

  @Test
  public void importFiles_whenImportingMultipleFiles_performsImport() throws Exception {
    createMobileDataDownload(multiSchemeFileDownloaderSupplier);

    DataFileGroup fileGroupWithInlineFile =
        DataFileGroup.newBuilder()
            .setGroupName(FILE_GROUP_NAME)
            .addFile(INLINE_DATA_FILE_1)
            .addFile(INLINE_DATA_FILE_2)
            .build();

    // Ensure that we add the file group successfully
    assertThat(
            mobileDataDownload
                .addFileGroup(
                    AddFileGroupRequest.newBuilder()
                        .setDataFileGroup(fileGroupWithInlineFile)
                        .build())
                .get())
        .isTrue();

    // Perform the import
    mobileDataDownload
        .importFiles(
            ImportFilesRequest.newBuilder()
                .setGroupName(FILE_GROUP_NAME)
                .setBuildId(fileGroupWithInlineFile.getBuildId())
                .setVariantId(fileGroupWithInlineFile.getVariantId())
                .setInlineFileMap(
                    ImmutableMap.of(FILE_ID_1, inlineFileSource1, FILE_ID_2, inlineFileSource2))
                .build())
        .get();

    // Assert that the resulting group is downloaded and contains a reference to on device file
    ClientFileGroup importResult =
        mobileDataDownload
            .getFileGroup(GetFileGroupRequest.newBuilder().setGroupName(FILE_GROUP_NAME).build())
            .get();

    assertThat(importResult).isNotNull();
    assertThat(importResult.getGroupName()).isEqualTo(FILE_GROUP_NAME);
    assertThat(importResult.getFileCount()).isEqualTo(2);
    assertThat(importResult.getStatus()).isEqualTo(Status.DOWNLOADED);
    assertThat(importResult.getFile(0).getFileUri()).isNotEmpty();
    assertThat(importResult.getFile(1).getFileUri()).isNotEmpty();

    assertThat(fileStorage.exists(Uri.parse(importResult.getFile(0).getFileUri()))).isTrue();
    assertThat(fileStorage.exists(Uri.parse(importResult.getFile(1).getFileUri()))).isTrue();
  }

  @Test
  public void importFiles_supportsMultipleCallsConcurrently() throws Exception {
    // Use BlockingFileDownloader to ensure both imports start around the same time.
    AtomicInteger fileDownloaderInvocationCount = new AtomicInteger(0);
    BlockingFileDownloader blockingFileDownloader =
        new BlockingFileDownloader(
            MoreExecutors.listeningDecorator(DOWNLOAD_EXECUTOR),
            new FileDownloader() {
              @Override
              public ListenableFuture<Void> startDownloading(DownloadRequest request) {
                fileDownloaderInvocationCount.addAndGet(1);
                return multiSchemeFileDownloaderSupplier.get().startDownloading(request);
              }
            });
    createMobileDataDownload(() -> blockingFileDownloader);

    DataFileGroup fileGroup1WithInlineFile =
        DataFileGroup.newBuilder()
            .setGroupName(FILE_GROUP_NAME)
            .addFile(INLINE_DATA_FILE_1)
            .build();

    DataFileGroup fileGroup2WithInlineFile =
        DataFileGroup.newBuilder()
            .setGroupName(FILE_GROUP_NAME + "2")
            .addFile(INLINE_DATA_FILE_2)
            .build();

    // Ensure that we add the file groups successfully
    assertThat(
            mobileDataDownload
                .addFileGroup(
                    AddFileGroupRequest.newBuilder()
                        .setDataFileGroup(fileGroup1WithInlineFile)
                        .build())
                .get())
        .isTrue();
    assertThat(
            mobileDataDownload
                .addFileGroup(
                    AddFileGroupRequest.newBuilder()
                        .setDataFileGroup(fileGroup2WithInlineFile)
                        .build())
                .get())
        .isTrue();

    // Perform the imports
    ListenableFuture<Void> importFuture1 =
        mobileDataDownload.importFiles(
            ImportFilesRequest.newBuilder()
                .setGroupName(FILE_GROUP_NAME)
                .setBuildId(fileGroup1WithInlineFile.getBuildId())
                .setVariantId(fileGroup1WithInlineFile.getVariantId())
                .setInlineFileMap(ImmutableMap.of(FILE_ID_1, inlineFileSource1))
                .build());

    ListenableFuture<Void> importFuture2 =
        mobileDataDownload.importFiles(
            ImportFilesRequest.newBuilder()
                .setGroupName(FILE_GROUP_NAME + "2")
                .setBuildId(fileGroup2WithInlineFile.getBuildId())
                .setVariantId(fileGroup2WithInlineFile.getVariantId())
                .setInlineFileMap(ImmutableMap.of(FILE_ID_2, inlineFileSource2))
                .build());

    // blocking file downloader should be waiting on the imports, block the test to ensure both
    // imports have started.
    blockingFileDownloader.waitForDownloadStarted();

    // unblock the imports so both happen concurrently.
    blockingFileDownloader.finishDownloading();

    // Wait for both futures to complete
    Futures.whenAllSucceed(importFuture1, importFuture2).call(() -> null, CONTROL_EXECUTOR).get();

    // Assert that the resulting group is downloaded and contains a reference to on device file
    ClientFileGroup importResult1 =
        mobileDataDownload
            .getFileGroup(GetFileGroupRequest.newBuilder().setGroupName(FILE_GROUP_NAME).build())
            .get();
    ClientFileGroup importResult2 =
        mobileDataDownload
            .getFileGroup(
                GetFileGroupRequest.newBuilder().setGroupName(FILE_GROUP_NAME + "2").build())
            .get();

    assertThat(importResult1).isNotNull();
    assertThat(importResult1.getFileCount()).isEqualTo(1);
    assertThat(importResult1.getStatus()).isEqualTo(Status.DOWNLOADED);
    assertThat(importResult1.getFile(0).getFileUri()).isNotEmpty();

    assertThat(importResult2).isNotNull();
    assertThat(importResult2.getFileCount()).isEqualTo(1);
    assertThat(importResult2.getStatus()).isEqualTo(Status.DOWNLOADED);
    assertThat(importResult2.getFile(0).getFileUri()).isNotEmpty();

    assertThat(fileStorage.exists(Uri.parse(importResult1.getFile(0).getFileUri()))).isTrue();
    assertThat(fileStorage.exists(Uri.parse(importResult2.getFile(0).getFileUri()))).isTrue();

    // assert that file downloader was called 2 times, 1 for each import.
    assertThat(fileDownloaderInvocationCount.get()).isEqualTo(2);
  }

  @Test
  public void importFiles_whenNewInlineFileSpecified_importsAndStoresFile() throws Exception {
    createMobileDataDownload(multiSchemeFileDownloaderSupplier);

    DataFileGroup fileGroupWithOneInlineFile =
        DataFileGroup.newBuilder()
            .setGroupName(FILE_GROUP_NAME)
            .addFile(INLINE_DATA_FILE_1)
            .build();
    ImmutableList<DataFile> updatedDataFileList = ImmutableList.of(INLINE_DATA_FILE_2);

    // Ensure that we add the file group successfully
    assertThat(
            mobileDataDownload
                .addFileGroup(
                    AddFileGroupRequest.newBuilder()
                        .setDataFileGroup(fileGroupWithOneInlineFile)
                        .build())
                .get())
        .isTrue();

    // Perform the import
    mobileDataDownload
        .importFiles(
            ImportFilesRequest.newBuilder()
                .setGroupName(FILE_GROUP_NAME)
                .setBuildId(fileGroupWithOneInlineFile.getBuildId())
                .setVariantId(fileGroupWithOneInlineFile.getVariantId())
                .setUpdatedDataFileList(updatedDataFileList)
                .setInlineFileMap(
                    ImmutableMap.of(FILE_ID_1, inlineFileSource1, FILE_ID_2, inlineFileSource2))
                .build())
        .get();

    // Assert that the resulting group is downloaded and contains both files
    ClientFileGroup importResult =
        mobileDataDownload
            .getFileGroup(GetFileGroupRequest.newBuilder().setGroupName(FILE_GROUP_NAME).build())
            .get();

    assertThat(importResult.getGroupName()).isEqualTo(FILE_GROUP_NAME);
    assertThat(importResult.getFileCount()).isEqualTo(2);
    assertThat(importResult.getStatus()).isEqualTo(Status.DOWNLOADED);
    assertThat(importResult.getFileList())
        .comparingElementsUsing(Correspondence.transforming(ClientFile::getFileId, "using file id"))
        .containsExactly(FILE_ID_1, FILE_ID_2);
    assertThat(importResult.getFile(0).getFileUri()).isNotEmpty();
    assertThat(importResult.getFile(1).getFileUri()).isNotEmpty();
  }

  @Test
  public void importFiles_whenNewInlineFileAddedToPendingGroup_importsAndStoresFile()
      throws Exception {
    createMobileDataDownload(multiSchemeFileDownloaderSupplier);

    DataFileGroup fileGroupWithStandardFile =
        DataFileGroup.newBuilder()
            .setGroupName(FILE_GROUP_NAME)
            .addFile(
                DataFile.newBuilder()
                    .setFileId(FILE_ID)
                    .setUrlToDownload(FILE_URL)
                    .setChecksum(FILE_CHECKSUM)
                    .setByteSize(FILE_SIZE)
                    .build())
            .build();
    ImmutableList<DataFile> updatedDataFileList = ImmutableList.of(INLINE_DATA_FILE_2);

    // Ensure that we add the file group successfully
    assertThat(
            mobileDataDownload
                .addFileGroup(
                    AddFileGroupRequest.newBuilder()
                        .setDataFileGroup(fileGroupWithStandardFile)
                        .build())
                .get())
        .isTrue();

    // Perform the import
    mobileDataDownload
        .importFiles(
            ImportFilesRequest.newBuilder()
                .setGroupName(FILE_GROUP_NAME)
                .setBuildId(fileGroupWithStandardFile.getBuildId())
                .setVariantId(fileGroupWithStandardFile.getVariantId())
                .setUpdatedDataFileList(updatedDataFileList)
                .setInlineFileMap(ImmutableMap.of(FILE_ID_2, inlineFileSource2))
                .build())
        .get();

    // Assert that the file is pending (does not return from getFileGroup)
    ClientFileGroup getFileGroupResult =
        mobileDataDownload
            .getFileGroup(GetFileGroupRequest.newBuilder().setGroupName(FILE_GROUP_NAME).build())
            .get();
    assertThat(getFileGroupResult).isNull();

    // Use getFileGroupsByFilter to get the file group
    ImmutableList<ClientFileGroup> allFileGroups =
        mobileDataDownload
            .getFileGroupsByFilter(
                GetFileGroupsByFilterRequest.newBuilder()
                    .setGroupNameOptional(Optional.of(FILE_GROUP_NAME))
                    .build())
            .get();

    // GetFileGroupsByFilter returns both downloaded and pending, so find the pending group.
    ClientFileGroup pendingInlineGroup = null;
    for (ClientFileGroup group : allFileGroups) {
      if (group.getStatus().equals(Status.PENDING)) {
        pendingInlineGroup = group;
        break;
      }
    }

    // Assert that the resulting group is pending and but contains imported file
    assertThat(pendingInlineGroup).isNotNull();
    assertThat(pendingInlineGroup.getGroupName()).isEqualTo(FILE_GROUP_NAME);
    assertThat(pendingInlineGroup.getFileCount()).isEqualTo(2);
    assertThat(pendingInlineGroup.getStatus()).isEqualTo(Status.PENDING);
    assertThat(pendingInlineGroup.getFileList())
        .comparingElementsUsing(Correspondence.transforming(ClientFile::getFileId, "using file id"))
        .containsExactly(FILE_ID, FILE_ID_2);
  }

  @Test
  public void importFiles_toNonExistentDataFileGroup_fails() throws Exception {
    createMobileDataDownload(multiSchemeFileDownloaderSupplier);

    FileSource inlineFileSource = FileSource.ofByteString(ByteString.copyFromUtf8("TEST_CONTENT"));

    // Perform the import
    ExecutionException ex =
        assertThrows(
            ExecutionException.class,
            () ->
                mobileDataDownload
                    .importFiles(
                        ImportFilesRequest.newBuilder()
                            .setGroupName(FILE_GROUP_NAME)
                            .setBuildId(0)
                            .setVariantId("")
                            .setInlineFileMap(ImmutableMap.of(FILE_ID_1, inlineFileSource))
                            .build())
                    .get());
    assertThat(ex).hasCauseThat().isInstanceOf(DownloadException.class);
    DownloadException dex = (DownloadException) ex.getCause();
    assertThat(dex.getDownloadResultCode()).isEqualTo(DownloadResultCode.GROUP_NOT_FOUND_ERROR);
  }

  @Test
  public void importFiles_whenMismatchedVersion_failToImport() throws Exception {
    createMobileDataDownload(multiSchemeFileDownloaderSupplier);

    DataFileGroup fileGroupWithInlineFile =
        DataFileGroup.newBuilder()
            .setGroupName(FILE_GROUP_NAME)
            .addFile(INLINE_DATA_FILE_1)
            .build();

    // Ensure that we add the file group successfully
    assertThat(
            mobileDataDownload
                .addFileGroup(
                    AddFileGroupRequest.newBuilder()
                        .setDataFileGroup(fileGroupWithInlineFile)
                        .build())
                .get())
        .isTrue();

    // Perform the import
    ExecutionException ex =
        assertThrows(
            ExecutionException.class,
            () ->
                mobileDataDownload
                    .importFiles(
                        ImportFilesRequest.newBuilder()
                            .setGroupName(FILE_GROUP_NAME)
                            .setBuildId(10)
                            .setVariantId("")
                            .setInlineFileMap(ImmutableMap.of(FILE_ID_1, inlineFileSource1))
                            .build())
                    .get());
    assertThat(ex).hasCauseThat().isInstanceOf(DownloadException.class);
    DownloadException dex = (DownloadException) ex.getCause();
    assertThat(dex.getDownloadResultCode()).isEqualTo(DownloadResultCode.GROUP_NOT_FOUND_ERROR);
  }

  @Test
  public void importFiles_whenImportFails_doesNotWriteUpdatedMetadata() throws Exception {
    createMobileDataDownload(multiSchemeFileDownloaderSupplier);

    // Create initial file group to import
    DataFileGroup initialFileGroup =
        DataFileGroup.newBuilder()
            .setGroupName(FILE_GROUP_NAME)
            .addFile(INLINE_DATA_FILE_1)
            .build();

    // Ensure that we add the file group successfully
    assertThat(
            mobileDataDownload
                .addFileGroup(
                    AddFileGroupRequest.newBuilder().setDataFileGroup(initialFileGroup).build())
                .get())
        .isTrue();

    // Perform the initial import
    mobileDataDownload
        .importFiles(
            ImportFilesRequest.newBuilder()
                .setGroupName(FILE_GROUP_NAME)
                .setBuildId(initialFileGroup.getBuildId())
                .setVariantId(initialFileGroup.getVariantId())
                .setInlineFileMap(ImmutableMap.of(FILE_ID_1, inlineFileSource1))
                .build())
        .get();

    // Assert that the resulting group is downloaded and contains a reference to on device file
    ClientFileGroup currentFileGroup =
        mobileDataDownload
            .getFileGroup(GetFileGroupRequest.newBuilder().setGroupName(FILE_GROUP_NAME).build())
            .get();

    assertThat(currentFileGroup).isNotNull();
    assertThat(currentFileGroup.getGroupName()).isEqualTo(FILE_GROUP_NAME);
    assertThat(currentFileGroup.getFileCount()).isEqualTo(1);
    assertThat(currentFileGroup.getStatus()).isEqualTo(Status.DOWNLOADED);
    assertThat(currentFileGroup.getFile(0).getFileUri()).isNotEmpty();

    // Use fake file backend to invoke a failure when importing another file
    fakeFileBackend.setFailure(OperationType.WRITE_STREAM, new IOException("test failure"));

    // Assert that importFiles fails due to failure importing file
    ExecutionException ex =
        assertThrows(
            ExecutionException.class,
            () ->
                mobileDataDownload
                    .importFiles(
                        ImportFilesRequest.newBuilder()
                            .setGroupName(FILE_GROUP_NAME)
                            .setBuildId(initialFileGroup.getBuildId())
                            .setVariantId(initialFileGroup.getVariantId())
                            .setUpdatedDataFileList(ImmutableList.of(INLINE_DATA_FILE_2))
                            .setInlineFileMap(ImmutableMap.of(FILE_ID_2, inlineFileSource2))
                            .build())
                    .get());
    assertThat(ex).hasCauseThat().isInstanceOf(AggregateException.class);
    AggregateException aex = (AggregateException) ex.getCause();
    assertThat(aex.getFailures()).hasSize(1);
    assertThat(aex.getFailures().get(0)).isInstanceOf(DownloadException.class);
    DownloadException dex = (DownloadException) aex.getFailures().get(0);
    assertThat(dex.getDownloadResultCode()).isEqualTo(DownloadResultCode.INLINE_FILE_IO_ERROR);

    // Get the file group again after the second import fails
    currentFileGroup =
        mobileDataDownload
            .getFileGroup(GetFileGroupRequest.newBuilder().setGroupName(FILE_GROUP_NAME).build())
            .get();

    // Assert that file group remains unchanged (no metadata change)
    assertThat(currentFileGroup).isNotNull();
    assertThat(currentFileGroup.getGroupName()).isEqualTo(FILE_GROUP_NAME);
    assertThat(currentFileGroup.getFileCount()).isEqualTo(1);
    assertThat(currentFileGroup.getStatus()).isEqualTo(Status.DOWNLOADED);
    assertThat(currentFileGroup.getFile(0).getFileUri()).isNotEmpty();
  }

  @Test
  public void importFiles_supportsDedup() throws Exception {
    // Use BlockingFileDownloader to block the import of a file indefinitely. This is used to ensure
    // a file import is in-progress before starting another import
    AtomicInteger fileDownloaderInvocationCount = new AtomicInteger(0);
    BlockingFileDownloader blockingFileDownloader =
        new BlockingFileDownloader(
            MoreExecutors.listeningDecorator(DOWNLOAD_EXECUTOR),
            new FileDownloader() {
              @Override
              public ListenableFuture<Void> startDownloading(DownloadRequest request) {
                fileDownloaderInvocationCount.addAndGet(1);
                return multiSchemeFileDownloaderSupplier.get().startDownloading(request);
              }
            });

    createMobileDataDownload(() -> blockingFileDownloader);

    DataFileGroup fileGroup1WithInlineFile =
        DataFileGroup.newBuilder()
            .setGroupName(FILE_GROUP_NAME)
            .addFile(INLINE_DATA_FILE_1)
            .build();

    DataFileGroup fileGroup2WithInlineFile =
        DataFileGroup.newBuilder()
            .setGroupName(FILE_GROUP_NAME + "2")
            .addFile(INLINE_DATA_FILE_1)
            .build();

    // Ensure that we add the file groups successfully
    assertThat(
            mobileDataDownload
                .addFileGroup(
                    AddFileGroupRequest.newBuilder()
                        .setDataFileGroup(fileGroup1WithInlineFile)
                        .build())
                .get())
        .isTrue();
    assertThat(
            mobileDataDownload
                .addFileGroup(
                    AddFileGroupRequest.newBuilder()
                        .setDataFileGroup(fileGroup2WithInlineFile)
                        .build())
                .get())
        .isTrue();

    // Start the first import and keep it in progress
    ListenableFuture<Void> importFilesFuture1 =
        mobileDataDownload.importFiles(
            ImportFilesRequest.newBuilder()
                .setGroupName(FILE_GROUP_NAME)
                .setBuildId(fileGroup1WithInlineFile.getBuildId())
                .setVariantId(fileGroup1WithInlineFile.getVariantId())
                .setInlineFileMap(ImmutableMap.of(FILE_ID_1, inlineFileSource1))
                .build());

    blockingFileDownloader.waitForDownloadStarted();

    // Start the second import after the first is already in-progress
    ListenableFuture<Void> importFilesFuture2 =
        mobileDataDownload.importFiles(
            ImportFilesRequest.newBuilder()
                .setGroupName(FILE_GROUP_NAME + "2")
                .setBuildId(fileGroup2WithInlineFile.getBuildId())
                .setVariantId(fileGroup2WithInlineFile.getVariantId())
                .setInlineFileMap(ImmutableMap.of(FILE_ID_1, inlineFileSource1))
                .build());

    // Allow the download to continue and trigger our delegate FileDownloader. If the future isn't
    // cancelled, the onSuccess callback should fail the test.
    blockingFileDownloader.finishDownloading();
    blockingFileDownloader.waitForDownloadCompleted();

    // wait for importFilesFuture2 to complete, check that importFiles1 is also complete
    importFilesFuture2.get();
    assertThat(importFilesFuture1.isDone()).isTrue();

    // Ensure that file downloader was only invoked once
    assertThat(fileDownloaderInvocationCount.get()).isEqualTo(1);

    mobileDataDownload.clear().get();
  }

  @Test
  public void importFiles_supportsCancellation() throws Exception {
    // Use BlockingFileDownloader to block the import of a file indefinitely. Check that the future
    // returned by importFiles fails with a cancellation exception
    BlockingFileDownloader blockingFileDownloader =
        new BlockingFileDownloader(
            MoreExecutors.listeningDecorator(DOWNLOAD_EXECUTOR),
            new FileDownloader() {
              @Override
              public ListenableFuture<Void> startDownloading(DownloadRequest downloadRequest) {
                ListenableFuture<Void> importTaskFuture = Futures.immediateVoidFuture();
                Futures.addCallback(
                    importTaskFuture,
                    new FutureCallback<Void>() {
                      @Override
                      public void onSuccess(Void result) {
                        // Should not get here since we will cancel the future.
                        fail();
                      }

                      @Override
                      public void onFailure(Throwable t) {
                        // Even though importTaskFuture was just created, this method should be
                        // invoked in the future chain that gets cancelled -- Ensure that the
                        // cancellation propagates to this future.
                        assertThat(importTaskFuture.isCancelled()).isTrue();
                      }
                    },
                    DOWNLOAD_EXECUTOR);
                return importTaskFuture;
              }
            });

    createMobileDataDownload(() -> blockingFileDownloader);

    DataFileGroup fileGroupWithInlineFile =
        DataFileGroup.newBuilder()
            .setGroupName(FILE_GROUP_NAME)
            .addFile(INLINE_DATA_FILE_1)
            .build();

    // Ensure that we add the file group successfully
    assertThat(
            mobileDataDownload
                .addFileGroup(
                    AddFileGroupRequest.newBuilder()
                        .setDataFileGroup(fileGroupWithInlineFile)
                        .build())
                .get())
        .isTrue();

    // Perform the import
    ListenableFuture<Void> importFilesFuture =
        mobileDataDownload.importFiles(
            ImportFilesRequest.newBuilder()
                .setGroupName(FILE_GROUP_NAME)
                .setBuildId(fileGroupWithInlineFile.getBuildId())
                .setVariantId(fileGroupWithInlineFile.getVariantId())
                .setInlineFileMap(ImmutableMap.of(FILE_ID_1, inlineFileSource1))
                .build());

    // Note: We could have a race condition when we call cancel() on the future, since the
    // FileDownloader's startDownloading() may not have been invoked yet. To prevent this, we first
    // wait for the file downloader to be invoked before performing the cancel.
    blockingFileDownloader.waitForDownloadStarted();

    importFilesFuture.cancel(/* mayInterruptIfRunning = */ true);

    // Allow the download to continue and trigger our delegate FileDownloader. If the future isn't
    // cancelled, the onSuccess callback should fail the test.
    blockingFileDownloader.finishDownloading();
    blockingFileDownloader.waitForDownloadCompleted();

    assertThat(importFilesFuture.isCancelled()).isTrue();

    mobileDataDownload.clear().get();
  }

  private void createMobileDataDownload(Supplier<FileDownloader> fileDownloaderSupplier) {
    mobileDataDownload =
        MobileDataDownloadBuilder.newBuilder()
            .setContext(context)
            .setControlExecutor(CONTROL_EXECUTOR)
            .setFileDownloaderSupplier(fileDownloaderSupplier)
            .setTaskScheduler(Optional.of(mockTaskScheduler))
            .setDeltaDecoderOptional(Optional.absent())
            .setFileStorage(fileStorage)
            .setNetworkUsageMonitor(mockNetworkUsageMonitor)
            .setDownloadMonitorOptional(Optional.of(mockDownloadProgressMonitor))
            .setFlagsOptional(Optional.of(flags))
            .build();
  }
}