| /* |
| * 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.lite; |
| |
| 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.ArgumentMatchers.eq; |
| 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 androidx.test.core.app.ApplicationProvider; |
| import com.google.android.libraries.mobiledatadownload.DownloadException; |
| import com.google.android.libraries.mobiledatadownload.downloader.DownloadConstraints; |
| import com.google.android.libraries.mobiledatadownload.downloader.FileDownloader; |
| import com.google.android.libraries.mobiledatadownload.testing.BlockingFileDownloader; |
| import com.google.common.base.Optional; |
| import com.google.common.base.Supplier; |
| 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.CountDownLatch; |
| import java.util.concurrent.ExecutionException; |
| import java.util.concurrent.Executor; |
| import java.util.concurrent.Executors; |
| import java.util.concurrent.ScheduledExecutorService; |
| 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; |
| |
| @RunWith(RobolectricTestRunner.class) |
| public final class DownloaderImplTest { |
| @Rule public final MockitoRule mocks = MockitoJUnit.rule(); |
| |
| // Use directExecutor to ensure the order of test verification. |
| private static final Executor CONTROL_EXECUTOR = MoreExecutors.directExecutor(); |
| private static final Executor BACKGROUND_EXECUTOR = Executors.newCachedThreadPool(); |
| private static final ScheduledExecutorService DOWNLOAD_EXECUTOR = |
| Executors.newScheduledThreadPool(2); |
| ListeningExecutorService listeningExecutorService = |
| MoreExecutors.listeningDecorator(DOWNLOAD_EXECUTOR); |
| |
| // 1MB file. |
| private static final String FILE_URL = |
| "https://www.gstatic.com/icing/idd/sample_group/sample_file_3_1519240701"; |
| |
| @Mock private SingleFileDownloadProgressMonitor mockDownloadMonitor; |
| @Mock private DownloadListener mockDownloadListener; |
| private Downloader downloader; |
| private Context context; |
| private DownloadRequest downloadRequest; |
| private final Uri destinationFileUri = |
| Uri.parse( |
| "android://com.google.android.libraries.mobiledatadownload/files/datadownload/shared/public/file_1"); |
| |
| @Mock private FileDownloader fileDownloader; |
| |
| @Captor ArgumentCaptor<DownloadListener> downloadListenerCaptor; |
| |
| @Captor |
| ArgumentCaptor<com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest> |
| downloadRequestCaptor; |
| |
| @Before |
| public void setUp() { |
| context = ApplicationProvider.getApplicationContext(); |
| downloader = |
| Downloader.newBuilder() |
| .setContext(context) |
| .setControlExecutor(CONTROL_EXECUTOR) |
| .setDownloadMonitor(mockDownloadMonitor) |
| .setFileDownloaderSupplier(() -> fileDownloader) |
| .setForegroundDownloadService(this.getClass()) // don't need to use the real one. |
| .build(); |
| |
| downloadRequest = |
| DownloadRequest.newBuilder() |
| .setDestinationFileUri(destinationFileUri) |
| .setUrlToDownload(FILE_URL) |
| .setDownloadConstraints(DownloadConstraints.NETWORK_CONNECTED) |
| .setNotificationContentTitle("File url: " + FILE_URL) |
| .build(); |
| |
| when(mockDownloadListener.onComplete()).thenReturn(Futures.immediateFuture(null)); |
| } |
| |
| @Test |
| public void download_whenRequestAlreadyMade_dedups() throws Exception { |
| // Use BlockingFileDownloader to ensure first download is in progress. |
| BlockingFileDownloader blockingFileDownloader = |
| new BlockingFileDownloader(listeningExecutorService); |
| Supplier<FileDownloader> blockingDownloaderSupplier = () -> blockingFileDownloader; |
| |
| DownloaderImpl downloaderImpl = |
| new DownloaderImpl( |
| context, |
| Optional.absent(), |
| CONTROL_EXECUTOR, |
| Optional.of(mockDownloadMonitor), |
| blockingDownloaderSupplier); |
| |
| int downloadFuturesInFlightCountBefore = downloaderImpl.keyToListenableFuture.size(); |
| |
| ListenableFuture<Void> downloadFuture1 = downloaderImpl.download(downloadRequest); |
| ListenableFuture<Void> downloadFuture2 = downloaderImpl.download(downloadRequest); |
| |
| assertThat(downloaderImpl.keyToListenableFuture).containsKey(destinationFileUri.toString()); |
| assertThat(downloaderImpl.keyToListenableFuture.size() - downloadFuturesInFlightCountBefore) |
| .isEqualTo(1); |
| |
| // Allow blocking download to finish |
| blockingFileDownloader.finishDownloading(); |
| |
| // Finish future 2 and assert that future 1 has completed as well |
| downloadFuture2.get(); |
| assertThat(downloadFuture1.isDone()).isTrue(); |
| |
| // TODO(b/155918406): Convert to Framework test and use TestingTaskBarrier to avoid sleep. |
| // Sleep for 1 sec to wait for the Future's callback to finish. |
| Thread.sleep(/* millis = */ 1000); |
| |
| // The completed download should be removed from keyToListenableFuture map. |
| assertThat(downloaderImpl.keyToListenableFuture) |
| .doesNotContainKey(destinationFileUri.toString()); |
| assertThat(downloaderImpl.keyToListenableFuture).hasSize(downloadFuturesInFlightCountBefore); |
| |
| // Reset state of blockingFileDownloader to prevent deadlocks |
| blockingFileDownloader.resetState(); |
| } |
| |
| @Test |
| public void download_whenRequestAlreadyMadeUsingForegroundService_dedups() throws Exception { |
| // Use BlockingFileDownloader to ensure first download is in progress. |
| BlockingFileDownloader blockingFileDownloader = |
| new BlockingFileDownloader(listeningExecutorService); |
| Supplier<FileDownloader> blockingDownloaderSupplier = () -> blockingFileDownloader; |
| |
| DownloaderImpl downloaderImpl = |
| new DownloaderImpl( |
| context, |
| Optional.of(this.getClass()), // don't need to use the real foreground download service. |
| CONTROL_EXECUTOR, |
| Optional.of(mockDownloadMonitor), |
| blockingDownloaderSupplier); |
| |
| int downloadFuturesInFlightCountBefore = downloaderImpl.keyToListenableFuture.size(); |
| |
| ListenableFuture<Void> downloadFuture1 = |
| downloaderImpl.downloadWithForegroundService(downloadRequest); |
| ListenableFuture<Void> downloadFuture2 = downloaderImpl.download(downloadRequest); |
| |
| assertThat(downloaderImpl.keyToListenableFuture).containsKey(destinationFileUri.toString()); |
| assertThat(downloaderImpl.keyToListenableFuture.size() - downloadFuturesInFlightCountBefore) |
| .isEqualTo(1); |
| |
| // Allow blocking download to finish |
| blockingFileDownloader.finishDownloading(); |
| |
| // Finish future 2 and assert that future 1 has completed as well |
| downloadFuture2.get(); |
| assertThat(downloadFuture1.isDone()).isTrue(); |
| |
| // TODO(b/155918406): Convert to Framework test and use TestingTaskBarrier to avoid sleep. |
| // Sleep for 1 sec to wait for the Future's callback to finish. |
| Thread.sleep(/* millis = */ 1000); |
| |
| // The completed download should be removed from keyToListenableFuture map. |
| assertThat(downloaderImpl.keyToListenableFuture) |
| .doesNotContainKey(destinationFileUri.toString()); |
| assertThat(downloaderImpl.keyToListenableFuture).hasSize(downloadFuturesInFlightCountBefore); |
| |
| // Reset state of blockingFileDownloader to prevent deadlocks |
| blockingFileDownloader.resetState(); |
| } |
| |
| @Test |
| public void download_beginsDownload() throws Exception { |
| when(fileDownloader.startDownloading(downloadRequestCaptor.capture())) |
| .thenReturn(Futures.immediateVoidFuture()); |
| |
| DownloaderImpl downloaderImpl = |
| new DownloaderImpl( |
| context, |
| Optional.absent(), |
| CONTROL_EXECUTOR, |
| Optional.of(mockDownloadMonitor), |
| () -> fileDownloader); |
| |
| downloadRequest = |
| DownloadRequest.newBuilder() |
| .setDestinationFileUri(destinationFileUri) |
| .setUrlToDownload(FILE_URL) |
| .setDownloadConstraints(DownloadConstraints.NETWORK_CONNECTED) |
| .setListenerOptional(Optional.of(mockDownloadListener)) |
| .build(); |
| |
| ListenableFuture<Void> downloadFuture = downloaderImpl.download(downloadRequest); |
| downloadFuture.get(); |
| |
| // TODO(b/155918406): Convert to Framework test and use TestingTaskBarrier to avoid sleep. |
| // Sleep for 1 sec to wait for the Future's callback to finish. |
| Thread.sleep(/* millis = */ 1000); |
| |
| // Verify that correct DownloadRequest is sent to underlying FileDownloader |
| com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest |
| actualDownloadRequest = downloadRequestCaptor.getValue(); |
| assertThat(actualDownloadRequest.fileUri()).isEqualTo(destinationFileUri); |
| assertThat(actualDownloadRequest.urlToDownload()).isEqualTo(FILE_URL); |
| assertThat(actualDownloadRequest.downloadConstraints()) |
| .isEqualTo(DownloadConstraints.NETWORK_CONNECTED); |
| |
| // Verify that downloadMonitor adds the listener |
| verify(mockDownloadMonitor) |
| .addDownloadListener(any(Uri.class), downloadListenerCaptor.capture()); |
| verify(fileDownloader) |
| .startDownloading( |
| any(com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest.class)); |
| |
| verify(mockDownloadMonitor).removeDownloadListener(destinationFileUri); |
| verify(mockDownloadListener).onComplete(); |
| |
| // Ensure that given download listener is the same one passed to download monitor |
| DownloadListener capturedDownloadListener = downloadListenerCaptor.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 { |
| when(fileDownloader.startDownloading(downloadRequestCaptor.capture())) |
| .thenReturn(Futures.immediateVoidFuture()); |
| when(mockDownloadListener.onComplete()) |
| .thenReturn(Futures.immediateFailedFuture(new Exception("test failure"))); |
| |
| DownloaderImpl downloaderImpl = |
| new DownloaderImpl( |
| context, |
| Optional.absent(), |
| CONTROL_EXECUTOR, |
| Optional.of(mockDownloadMonitor), |
| () -> fileDownloader); |
| |
| downloadRequest = |
| DownloadRequest.newBuilder() |
| .setDestinationFileUri(destinationFileUri) |
| .setUrlToDownload(FILE_URL) |
| .setDownloadConstraints(DownloadConstraints.NETWORK_CONNECTED) |
| .setListenerOptional(Optional.of(mockDownloadListener)) |
| .build(); |
| |
| downloader.download(downloadRequest).get(); |
| |
| // TODO(b/155918406): Convert to Framework test and use TestingTaskBarrier to avoid sleep. |
| // Sleep for 1 sec to wait for the Future's callback to finish. |
| Thread.sleep(/* millis = */ 1000); |
| |
| // Ensure that future is still removed from internal map |
| assertThat(downloaderImpl.keyToListenableFuture) |
| .doesNotContainKey(downloadRequest.destinationFileUri().toString()); |
| |
| // Verify that DownloadMonitor handled DownloadListener properly |
| verify(mockDownloadMonitor).addDownloadListener(destinationFileUri, mockDownloadListener); |
| verify(mockDownloadMonitor).removeDownloadListener(destinationFileUri); |
| |
| // Verify that download was started |
| verify(fileDownloader).startDownloading(any()); |
| |
| // Verify the DownloadListeners onComplete was invoked |
| verify(mockDownloadListener).onComplete(); |
| } |
| |
| @Test |
| public void download_whenListenerProvided_waitsForOnCompleteToFinish() throws Exception { |
| when(fileDownloader.startDownloading(any())).thenReturn(Futures.immediateVoidFuture()); |
| |
| // Use a latch to simulate a long running DownloadListener.onComplete |
| CountDownLatch blockingOnCompleteLatch = new CountDownLatch(1); |
| |
| DownloaderImpl downloaderImpl = |
| new DownloaderImpl( |
| context, |
| Optional.absent(), |
| CONTROL_EXECUTOR, |
| Optional.of(mockDownloadMonitor), |
| () -> fileDownloader); |
| |
| downloadRequest = |
| DownloadRequest.newBuilder() |
| .setDestinationFileUri(destinationFileUri) |
| .setUrlToDownload(FILE_URL) |
| .setDownloadConstraints(DownloadConstraints.NETWORK_CONNECTED) |
| .setListenerOptional( |
| Optional.of( |
| new DownloadListener() { |
| @Override |
| public void onProgress(long currentSize) {} |
| |
| @Override |
| public void onPausedForConnectivity() {} |
| |
| @Override |
| public void onFailure(Throwable t) {} |
| |
| @Override |
| public ListenableFuture<Void> onComplete() { |
| return Futures.submitAsync( |
| () -> { |
| try { |
| // Verify that future map still contains download future. |
| assertThat(downloaderImpl.keyToListenableFuture) |
| .containsKey(destinationFileUri.toString()); |
| blockingOnCompleteLatch.await(); |
| } catch (InterruptedException e) { |
| // Ignore. |
| } |
| return Futures.immediateVoidFuture(); |
| }, |
| BACKGROUND_EXECUTOR); |
| } |
| })) |
| .build(); |
| |
| downloaderImpl.download(downloadRequest).get(); |
| |
| // Verify that the download future map still contains the download future. |
| assertThat(downloaderImpl.keyToListenableFuture).containsKey(destinationFileUri.toString()); |
| |
| // TODO(b/155918406): Convert to Framework test and use TestingTaskBarrier to avoid sleep. |
| // Sleep for 1 sec to wait for the Future's callback to finish. |
| Thread.sleep(/* millis = */ 1000); |
| |
| // Finish the onComplete method. |
| blockingOnCompleteLatch.countDown(); |
| |
| // TODO(b/155918406): Convert to Framework test and use TestingTaskBarrier to avoid sleep. |
| // Sleep for 1 sec to wait for the Future's callback to finish. |
| Thread.sleep(/* millis = */ 1000); |
| |
| // The completed download should be removed from keyToListenableFuture map. |
| assertThat(downloaderImpl.keyToListenableFuture) |
| .doesNotContainKey(destinationFileUri.toString()); |
| assertThat(downloaderImpl.keyToListenableFuture).isEmpty(); |
| |
| // Verify DownloadListener was added/removed |
| verify(mockDownloadMonitor).addDownloadListener(eq(destinationFileUri), any()); |
| verify(mockDownloadMonitor).removeDownloadListener(destinationFileUri); |
| } |
| |
| @Test |
| public void download_whenDownloadFails_reportsFailure() throws Exception { |
| DownloadException downloadException = |
| DownloadException.builder().setDownloadResultCode(ANDROID_DOWNLOADER_UNKNOWN).build(); |
| when(fileDownloader.startDownloading(downloadRequestCaptor.capture())) |
| .thenReturn(Futures.immediateFailedFuture(downloadException)); |
| |
| DownloaderImpl downloaderImpl = |
| new DownloaderImpl( |
| context, |
| Optional.absent(), |
| CONTROL_EXECUTOR, |
| Optional.of(mockDownloadMonitor), |
| () -> fileDownloader); |
| |
| downloadRequest = |
| DownloadRequest.newBuilder() |
| .setDestinationFileUri(destinationFileUri) |
| .setUrlToDownload(FILE_URL) |
| .setDownloadConstraints(DownloadConstraints.NETWORK_CONNECTED) |
| .setListenerOptional(Optional.of(mockDownloadListener)) |
| .build(); |
| |
| ListenableFuture<Void> downloadFuture = downloaderImpl.download(downloadRequest); |
| assertThrows(ExecutionException.class, downloadFuture::get); |
| DownloadException e = LabsFutures.getFailureCauseAs(downloadFuture, DownloadException.class); |
| assertThat(e.getDownloadResultCode()).isEqualTo(ANDROID_DOWNLOADER_UNKNOWN); |
| |
| // Verify that file download was started and failed |
| verify(fileDownloader).startDownloading(any()); |
| com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest |
| actualDownloadRequest = downloadRequestCaptor.getValue(); |
| assertThat(actualDownloadRequest.fileUri()).isEqualTo(destinationFileUri); |
| assertThat(actualDownloadRequest.urlToDownload()).isEqualTo(FILE_URL); |
| assertThat(actualDownloadRequest.downloadConstraints()) |
| .isEqualTo(DownloadConstraints.NETWORK_CONNECTED); |
| |
| // Verify that DownloadMonitor added/removed DownloadListener |
| verify(mockDownloadMonitor).addDownloadListener(destinationFileUri, mockDownloadListener); |
| verify(mockDownloadMonitor).removeDownloadListener(destinationFileUri); |
| |
| // Verify that DownloadListener.onFailure was invoked with failure |
| verify(mockDownloadListener).onFailure(downloadException); |
| verify(mockDownloadListener, times(0)).onComplete(); |
| } |
| |
| @Test |
| public void download_whenReturnedFutureIsCanceled_cancelsDownload() throws Exception { |
| // Use BlockingFileDownloader to simulate long download |
| BlockingFileDownloader blockingFileDownloader = |
| new BlockingFileDownloader(listeningExecutorService); |
| |
| DownloaderImpl downloaderImpl = |
| new DownloaderImpl( |
| context, |
| Optional.absent(), |
| CONTROL_EXECUTOR, |
| Optional.of(mockDownloadMonitor), |
| () -> blockingFileDownloader); |
| |
| ListenableFuture<Void> downloadFuture = downloaderImpl.download(downloadRequest); |
| |
| assertThat(downloaderImpl.keyToListenableFuture) |
| .containsKey(downloadRequest.destinationFileUri().toString()); |
| |
| downloadFuture.cancel(true); |
| |
| // The download future should no longer be included in the future map |
| assertThat(downloaderImpl.keyToListenableFuture) |
| .doesNotContainKey(downloadRequest.destinationFileUri().toString()); |
| |
| // Reset state of blocking file downloader to prevent deadlocks |
| blockingFileDownloader.resetState(); |
| } |
| |
| @Test |
| public void download_whenMonitorNotProvided_whenDownloadSucceeds_waitsForListenerOnComplete() |
| throws Exception { |
| when(fileDownloader.startDownloading(any())).thenReturn(Futures.immediateVoidFuture()); |
| |
| // Use a latch to simulate a long running DownloadListener.onComplete |
| CountDownLatch blockingOnCompleteLatch = new CountDownLatch(1); |
| |
| DownloaderImpl downloaderImpl = |
| new DownloaderImpl( |
| context, Optional.absent(), CONTROL_EXECUTOR, Optional.absent(), () -> fileDownloader); |
| |
| downloadRequest = |
| DownloadRequest.newBuilder() |
| .setDestinationFileUri(destinationFileUri) |
| .setUrlToDownload(FILE_URL) |
| .setDownloadConstraints(DownloadConstraints.NETWORK_CONNECTED) |
| .setListenerOptional( |
| Optional.of( |
| new DownloadListener() { |
| @Override |
| public void onProgress(long currentSize) {} |
| |
| @Override |
| public void onPausedForConnectivity() {} |
| |
| @Override |
| public void onFailure(Throwable t) {} |
| |
| @Override |
| public ListenableFuture<Void> onComplete() { |
| return Futures.submitAsync( |
| () -> { |
| try { |
| // Verify that future map still contains download future. |
| assertThat(downloaderImpl.keyToListenableFuture) |
| .containsKey(destinationFileUri.toString()); |
| blockingOnCompleteLatch.await(); |
| } catch (InterruptedException e) { |
| // Ignore. |
| } |
| return Futures.immediateVoidFuture(); |
| }, |
| BACKGROUND_EXECUTOR); |
| } |
| })) |
| .build(); |
| |
| downloaderImpl.download(downloadRequest).get(); |
| |
| // Verify that the download future map still contains the download future. |
| assertThat(downloaderImpl.keyToListenableFuture).containsKey(destinationFileUri.toString()); |
| |
| // TODO(b/155918406): Convert to Framework test and use TestingTaskBarrier to avoid sleep. |
| // Sleep for 1 sec to wait for the Future's callback to finish. |
| Thread.sleep(/* millis = */ 1000); |
| |
| // Finish the onComplete method. |
| blockingOnCompleteLatch.countDown(); |
| |
| // TODO(b/155918406): Convert to Framework test and use TestingTaskBarrier to avoid sleep. |
| // Sleep for 1 sec to wait for the Future's callback to finish. |
| Thread.sleep(/* millis = */ 1000); |
| |
| // The completed download should be removed from keyToListenableFuture map. |
| assertThat(downloaderImpl.keyToListenableFuture) |
| .doesNotContainKey(destinationFileUri.toString()); |
| assertThat(downloaderImpl.keyToListenableFuture).isEmpty(); |
| } |
| |
| @Test |
| public void download_whenMonitorNotProvided_whenDownloadFails_reportsFailure() throws Exception { |
| DownloadException downloadException = |
| DownloadException.builder().setDownloadResultCode(ANDROID_DOWNLOADER_UNKNOWN).build(); |
| when(fileDownloader.startDownloading(downloadRequestCaptor.capture())) |
| .thenReturn(Futures.immediateFailedFuture(downloadException)); |
| |
| DownloaderImpl downloaderImpl = |
| new DownloaderImpl( |
| context, Optional.absent(), CONTROL_EXECUTOR, Optional.absent(), () -> fileDownloader); |
| |
| downloadRequest = |
| DownloadRequest.newBuilder() |
| .setDestinationFileUri(destinationFileUri) |
| .setUrlToDownload(FILE_URL) |
| .setDownloadConstraints(DownloadConstraints.NETWORK_CONNECTED) |
| .setListenerOptional(Optional.of(mockDownloadListener)) |
| .build(); |
| |
| ListenableFuture<Void> downloadFuture = downloaderImpl.download(downloadRequest); |
| assertThrows(ExecutionException.class, downloadFuture::get); |
| DownloadException e = LabsFutures.getFailureCauseAs(downloadFuture, DownloadException.class); |
| assertThat(e.getDownloadResultCode()).isEqualTo(ANDROID_DOWNLOADER_UNKNOWN); |
| |
| // Verify that file download was started and failed |
| verify(fileDownloader).startDownloading(any()); |
| com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest |
| actualDownloadRequest = downloadRequestCaptor.getValue(); |
| assertThat(actualDownloadRequest.fileUri()).isEqualTo(destinationFileUri); |
| assertThat(actualDownloadRequest.urlToDownload()).isEqualTo(FILE_URL); |
| assertThat(actualDownloadRequest.downloadConstraints()) |
| .isEqualTo(DownloadConstraints.NETWORK_CONNECTED); |
| |
| // Verify that DownloadListener.onFailure was invoked with failure |
| verify(mockDownloadListener).onFailure(downloadException); |
| verify(mockDownloadListener, times(0)).onComplete(); |
| } |
| |
| @Test |
| public void downloadWithForegroundService_requiresForegroundDownloadService() throws Exception { |
| // Create downloader without providing foreground service |
| downloader = |
| Downloader.newBuilder() |
| .setContext(context) |
| .setControlExecutor(CONTROL_EXECUTOR) |
| .setDownloadMonitor(mockDownloadMonitor) |
| .setFileDownloaderSupplier(() -> fileDownloader) |
| .build(); |
| |
| // Without foreground service, download call should fail with IllegalStateException |
| ListenableFuture<Void> downloadFuture = |
| downloader.downloadWithForegroundService(downloadRequest); |
| ExecutionException e = assertThrows(ExecutionException.class, downloadFuture::get); |
| assertThat(e).hasCauseThat().isInstanceOf(IllegalStateException.class); |
| |
| // Verify that underlying download is not started |
| verify(mockDownloadMonitor, times(0)) |
| .addDownloadListener(any(Uri.class), any(DownloadListener.class)); |
| verify(fileDownloader, times(0)) |
| .startDownloading( |
| any(com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest.class)); |
| } |
| |
| @Test |
| public void downloadWithForegroundService_requiresDownloadMonitor() throws Exception { |
| // Create downloader without providing DownloadMonitor |
| downloader = |
| Downloader.newBuilder() |
| .setContext(context) |
| .setControlExecutor(CONTROL_EXECUTOR) |
| .setForegroundDownloadService( |
| this.getClass()) // don't need to use the real foreground download service. |
| .setFileDownloaderSupplier(() -> fileDownloader) |
| .build(); |
| |
| // Without foreground service, download call should fail with IllegalStateException |
| ListenableFuture<Void> downloadFuture = |
| downloader.downloadWithForegroundService(downloadRequest); |
| ExecutionException e = assertThrows(ExecutionException.class, downloadFuture::get); |
| assertThat(e).hasCauseThat().isInstanceOf(IllegalStateException.class); |
| |
| // Verify that underlying download is not started |
| verify(mockDownloadMonitor, times(0)) |
| .addDownloadListener(any(Uri.class), any(DownloadListener.class)); |
| verify(fileDownloader, times(0)) |
| .startDownloading( |
| any(com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest.class)); |
| } |
| |
| @Test |
| public void downloadWithForegroundService_whenRequestAlreadyMade_dedups() throws Exception { |
| // Use BlockingFileDownloader to control when the download will finish. |
| BlockingFileDownloader blockingFileDownloader = |
| new BlockingFileDownloader(listeningExecutorService); |
| Supplier<FileDownloader> blockingDownloaderSupplier = () -> blockingFileDownloader; |
| |
| DownloaderImpl downloaderImpl = |
| new DownloaderImpl( |
| context, |
| Optional.of(this.getClass()), // don't need to use the real foreground download service. |
| CONTROL_EXECUTOR, |
| Optional.of(mockDownloadMonitor), |
| blockingDownloaderSupplier); |
| |
| int downloadFuturesInFlightCountBefore = downloaderImpl.keyToListenableFuture.size(); |
| |
| ListenableFuture<Void> downloadFuture1 = |
| downloaderImpl.downloadWithForegroundService(downloadRequest); |
| ListenableFuture<Void> downloadFuture2 = |
| downloaderImpl.downloadWithForegroundService(downloadRequest); |
| |
| assertThat(downloaderImpl.keyToListenableFuture).containsKey(destinationFileUri.toString()); |
| |
| assertThat(downloaderImpl.keyToListenableFuture.size() - downloadFuturesInFlightCountBefore) |
| .isEqualTo(1); |
| |
| // 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(); |
| assertThat(downloadFuture1.isDone()).isTrue(); |
| |
| // TODO(b/147583059): Convert to Framework test and use TestingTaskBarrier to avoid sleep. |
| // Sleep for 1 sec to wait for the Future's callback to finish. |
| Thread.sleep(/*millis=*/ 1000); |
| // The completed download is removed from the uriToListenableFuture Map. |
| assertThat(downloaderImpl.keyToListenableFuture) |
| .doesNotContainKey(destinationFileUri.toString()); |
| assertThat(downloaderImpl.keyToListenableFuture).hasSize(downloadFuturesInFlightCountBefore); |
| |
| // Reset state of blockingFileDownloader to prevent deadlocks |
| blockingFileDownloader.resetState(); |
| } |
| |
| @Test |
| public void downloadWithForegroundService_whenRequestAlreadyMadeWithoutForegroundService_dedups() |
| throws Exception { |
| // Use BlockingFileDownloader to control when the download will finish. |
| BlockingFileDownloader blockingFileDownloader = |
| new BlockingFileDownloader(listeningExecutorService); |
| Supplier<FileDownloader> blockingDownloaderSupplier = () -> blockingFileDownloader; |
| |
| DownloaderImpl downloaderImpl = |
| new DownloaderImpl( |
| context, |
| Optional.of(this.getClass()), // don't need to use the real foreground download service. |
| CONTROL_EXECUTOR, |
| Optional.of(mockDownloadMonitor), |
| blockingDownloaderSupplier); |
| |
| int downloadFuturesInFlightCountBefore = downloaderImpl.keyToListenableFuture.size(); |
| |
| ListenableFuture<Void> downloadFuture1 = downloaderImpl.download(downloadRequest); |
| ListenableFuture<Void> downloadFuture2 = |
| downloaderImpl.downloadWithForegroundService(downloadRequest); |
| |
| assertThat(downloaderImpl.keyToListenableFuture).containsKey(destinationFileUri.toString()); |
| |
| assertThat(downloaderImpl.keyToListenableFuture.size() - downloadFuturesInFlightCountBefore) |
| .isEqualTo(1); |
| |
| // 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(); |
| assertThat(downloadFuture1.isDone()).isTrue(); |
| |
| // TODO(b/155918406): Convert to Framework test and use TestingTaskBarrier to avoid sleep. |
| // Sleep for 1 sec to wait for the Future's callback to finish. |
| Thread.sleep(/*millis=*/ 1000); |
| // The completed download is removed from the uriToListenableFuture Map. |
| assertThat(downloaderImpl.keyToListenableFuture) |
| .doesNotContainKey(destinationFileUri.toString()); |
| assertThat(downloaderImpl.keyToListenableFuture).hasSize(downloadFuturesInFlightCountBefore); |
| |
| // Reset state of blockingFileDownloader to prevent deadlocks |
| blockingFileDownloader.resetState(); |
| } |
| |
| @Test |
| public void downloadWithForegroundService() throws ExecutionException, InterruptedException { |
| ArgumentCaptor<DownloadListener> downloadListenerCaptor = |
| ArgumentCaptor.forClass(DownloadListener.class); |
| ArgumentCaptor<com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest> |
| downloadRequestCaptor = |
| ArgumentCaptor.forClass( |
| com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest.class); |
| when(fileDownloader.startDownloading(downloadRequestCaptor.capture())) |
| .thenReturn(Futures.immediateFuture(null)); |
| |
| downloadRequest = |
| DownloadRequest.newBuilder() |
| .setDestinationFileUri(destinationFileUri) |
| .setUrlToDownload(FILE_URL) |
| .setDownloadConstraints(DownloadConstraints.NETWORK_CONNECTED) |
| .setNotificationContentTitle("File url: " + FILE_URL) |
| .setListenerOptional(Optional.of(mockDownloadListener)) |
| .build(); |
| |
| ListenableFuture<Void> downloadFuture = |
| downloader.downloadWithForegroundService(downloadRequest); |
| downloadFuture.get(); |
| |
| // TODO(b/147583059): Convert to Framework test and use TestingTaskBarrier to avoid sleep. |
| // Sleep for 1 sec to wait for the Future's callback to finish. |
| Thread.sleep(/*millis=*/ 1000); |
| |
| // Verify that the correct DownloadRequest is sent to underderlying FileDownloader. |
| com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest |
| actualDownloadRequest = downloadRequestCaptor.getValue(); |
| assertThat(actualDownloadRequest.fileUri()).isEqualTo(destinationFileUri); |
| assertThat(actualDownloadRequest.urlToDownload()).isEqualTo(FILE_URL); |
| assertThat(actualDownloadRequest.downloadConstraints()) |
| .isEqualTo(DownloadConstraints.NETWORK_CONNECTED); |
| |
| // Verify that downloadMonitor will add a DownloadListener. |
| verify(mockDownloadMonitor) |
| .addDownloadListener(any(Uri.class), downloadListenerCaptor.capture()); |
| verify(fileDownloader) |
| .startDownloading( |
| any(com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest.class)); |
| |
| verify(mockDownloadMonitor).removeDownloadListener(destinationFileUri); |
| |
| verify(mockDownloadListener).onComplete(); |
| |
| // Now simulate other DownloadListener's callbacks: |
| downloadListenerCaptor.getValue().onProgress(10); |
| verify(mockDownloadListener).onProgress(10); |
| downloadListenerCaptor.getValue().onPausedForConnectivity(); |
| DownloadException downloadException = |
| DownloadException.builder().setDownloadResultCode(ANDROID_DOWNLOADER_UNKNOWN).build(); |
| downloadListenerCaptor.getValue().onFailure(downloadException); |
| |
| verify(mockDownloadListener).onPausedForConnectivity(); |
| verify(mockDownloadListener).onFailure(downloadException); |
| } |
| |
| @Test |
| public void downloadWithForegroundService_clientOnCompleteFailed() |
| throws ExecutionException, InterruptedException { |
| ArgumentCaptor<DownloadListener> downloadListenerCaptor = |
| ArgumentCaptor.forClass(DownloadListener.class); |
| ArgumentCaptor<com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest> |
| downloadRequestCaptor = |
| ArgumentCaptor.forClass( |
| com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest.class); |
| when(fileDownloader.startDownloading(downloadRequestCaptor.capture())) |
| .thenReturn(Futures.immediateFuture(null)); |
| |
| // Client's provided DownloadListener.onComplete failed. |
| when(mockDownloadListener.onComplete()) |
| .thenReturn(Futures.immediateFailedFuture(new Exception())); |
| |
| downloadRequest = |
| DownloadRequest.newBuilder() |
| .setDestinationFileUri(destinationFileUri) |
| .setUrlToDownload(FILE_URL) |
| .setDownloadConstraints(DownloadConstraints.NETWORK_CONNECTED) |
| .setNotificationContentTitle("File url: " + FILE_URL) |
| .setListenerOptional(Optional.of(mockDownloadListener)) |
| .build(); |
| |
| ListenableFuture<Void> downloadFuture = |
| downloader.downloadWithForegroundService(downloadRequest); |
| downloadFuture.get(); |
| |
| // TODO(b/147583059): Convert to Framework test and use TestingTaskBarrier to avoid sleep. |
| // Sleep for 1 sec to wait for the Future's callback to finish. |
| Thread.sleep(/*millis=*/ 1000); |
| |
| // Verify that the correct DownloadRequest is sent to underderlying FileDownloader. |
| com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest |
| actualDownloadRequest = downloadRequestCaptor.getValue(); |
| assertThat(actualDownloadRequest.fileUri()).isEqualTo(destinationFileUri); |
| assertThat(actualDownloadRequest.urlToDownload()).isEqualTo(FILE_URL); |
| assertThat(actualDownloadRequest.downloadConstraints()) |
| .isEqualTo(DownloadConstraints.NETWORK_CONNECTED); |
| |
| // Verify that downloadMonitor will add a DownloadListener. |
| verify(mockDownloadMonitor) |
| .addDownloadListener(any(Uri.class), downloadListenerCaptor.capture()); |
| verify(fileDownloader) |
| .startDownloading( |
| any(com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest.class)); |
| |
| verify(mockDownloadMonitor).removeDownloadListener(destinationFileUri); |
| |
| verify(mockDownloadListener).onComplete(); |
| } |
| |
| @Test |
| public void downloadWithForegroundService_clientOnCompleteBlocked() |
| throws ExecutionException, InterruptedException { |
| ArgumentCaptor<com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest> |
| downloadRequestCaptor = |
| ArgumentCaptor.forClass( |
| com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest.class); |
| when(fileDownloader.startDownloading(downloadRequestCaptor.capture())) |
| .thenReturn(Futures.immediateFuture(null)); |
| |
| // Using latch to block on client's onComplete to simulate a very long running onComplete. |
| CountDownLatch blockingOnCompleteLatch = new CountDownLatch(1); |
| |
| DownloaderImpl downloaderImpl = |
| new DownloaderImpl( |
| context, |
| Optional.of(this.getClass()), // don't need to use the real foreground download service |
| CONTROL_EXECUTOR, |
| Optional.of(mockDownloadMonitor), |
| () -> fileDownloader); |
| |
| downloadRequest = |
| DownloadRequest.newBuilder() |
| .setDestinationFileUri(destinationFileUri) |
| .setUrlToDownload(FILE_URL) |
| .setDownloadConstraints(DownloadConstraints.NETWORK_CONNECTED) |
| .setNotificationContentTitle("File url: " + FILE_URL) |
| .setListenerOptional( |
| Optional.of( |
| new DownloadListener() { |
| @Override |
| public void onProgress(long currentSize) {} |
| |
| @Override |
| public ListenableFuture<Void> onComplete() { |
| return Futures.submitAsync( |
| () -> { |
| try { |
| // Block the onComplete task. |
| // Verify that before client's onComplete finishes, the on-going |
| // download future map still contain this download. This means |
| // the Foreground Download Service has not be shut down yet. |
| assertThat(downloaderImpl.keyToListenableFuture) |
| .containsKey(destinationFileUri.toString()); |
| blockingOnCompleteLatch.await(); |
| } catch (InterruptedException e) { |
| // Ignore. |
| } |
| return Futures.immediateFuture(null); |
| }, |
| BACKGROUND_EXECUTOR); |
| } |
| |
| @Override |
| public void onFailure(Throwable t) {} |
| |
| @Override |
| public void onPausedForConnectivity() {} |
| })) |
| .build(); |
| |
| ListenableFuture<Void> downloadFuture = |
| downloaderImpl.downloadWithForegroundService(downloadRequest); |
| downloadFuture.get(); |
| |
| // TODO(b/147583059): Convert to Framework test and use TestingTaskBarrier to avoid sleep. |
| // Sleep for 1 sec to wait for the Future's callback to finish. |
| Thread.sleep(/*millis=*/ 1000); |
| |
| // Verify that this download future has not been removed from the keyToListenableFuture map yet. |
| assertThat(downloaderImpl.keyToListenableFuture).containsKey(destinationFileUri.toString()); |
| |
| // Now let's the onComplete finishes. |
| blockingOnCompleteLatch.countDown(); |
| |
| // TODO(b/147583059): Convert to Framework test and use TestingTaskBarrier to avoid sleep. |
| // Sleep for 1 sec to wait for the Future's callback on onComplete to finish. |
| Thread.sleep(/*millis=*/ 1000); |
| |
| // The completed download is removed from the keyToListenableFuture Map. |
| assertThat(downloaderImpl.keyToListenableFuture) |
| .doesNotContainKey(destinationFileUri.toString()); |
| assertThat(downloaderImpl.keyToListenableFuture).isEmpty(); |
| |
| verify(mockDownloadMonitor).removeDownloadListener(destinationFileUri); |
| } |
| |
| @Test |
| public void downloadWithForegroundService_failure() |
| throws ExecutionException, InterruptedException { |
| ArgumentCaptor<DownloadListener> downloadListenerCaptor = |
| ArgumentCaptor.forClass(DownloadListener.class); |
| ArgumentCaptor<com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest> |
| downloadRequestCaptor = |
| ArgumentCaptor.forClass( |
| com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest.class); |
| DownloadException downloadException = |
| DownloadException.builder().setDownloadResultCode(ANDROID_DOWNLOADER_UNKNOWN).build(); |
| |
| when(fileDownloader.startDownloading(downloadRequestCaptor.capture())) |
| .thenReturn(Futures.immediateFailedFuture(downloadException)); |
| |
| downloadRequest = |
| DownloadRequest.newBuilder() |
| .setDestinationFileUri(destinationFileUri) |
| .setUrlToDownload(FILE_URL) |
| .setDownloadConstraints(DownloadConstraints.NETWORK_CONNECTED) |
| .setNotificationContentTitle("File url: " + FILE_URL) |
| .setListenerOptional(Optional.of(mockDownloadListener)) |
| .build(); |
| |
| ListenableFuture<Void> downloadFuture = |
| downloader.downloadWithForegroundService(downloadRequest); |
| assertThrows(ExecutionException.class, downloadFuture::get); |
| DownloadException e = LabsFutures.getFailureCauseAs(downloadFuture, DownloadException.class); |
| assertThat(e.getDownloadResultCode()).isEqualTo(ANDROID_DOWNLOADER_UNKNOWN); |
| |
| // TODO(b/147583059): Convert to Framework test and use TestingTaskBarrier to avoid sleep. |
| // Sleep for 1 sec to wait for the listener to finish. |
| Thread.sleep(/*millis=*/ 1000); |
| |
| // Verify that the correct DownloadRequest is sent to underderlying FileDownloader. |
| com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest |
| actualDownloadRequest = downloadRequestCaptor.getValue(); |
| assertThat(actualDownloadRequest.fileUri()).isEqualTo(destinationFileUri); |
| assertThat(actualDownloadRequest.urlToDownload()).isEqualTo(FILE_URL); |
| assertThat(actualDownloadRequest.downloadConstraints()) |
| .isEqualTo(DownloadConstraints.NETWORK_CONNECTED); |
| |
| // Verify that downloadMonitor will add a DownloadListener. |
| verify(mockDownloadMonitor) |
| .addDownloadListener(any(Uri.class), downloadListenerCaptor.capture()); |
| verify(fileDownloader) |
| .startDownloading( |
| any(com.google.android.libraries.mobiledatadownload.downloader.DownloadRequest.class)); |
| |
| verify(mockDownloadMonitor).removeDownloadListener(destinationFileUri); |
| |
| // Since the download failed, onComplete will not be called but onFailure. |
| verify(mockDownloadListener, times(0)).onComplete(); |
| verify(mockDownloadListener).onFailure(downloadException); |
| } |
| |
| @Test |
| public void cancelDownloadWithForegroundService() { |
| // Use BlockingFileDownloader to control when the download will finish. |
| BlockingFileDownloader blockingFileDownloader = |
| new BlockingFileDownloader(listeningExecutorService); |
| Supplier<FileDownloader> blockingDownloaderSupplier = () -> blockingFileDownloader; |
| |
| DownloaderImpl downloaderImpl = |
| new DownloaderImpl( |
| context, |
| Optional.of(this.getClass()), // don't need to use the real foreground download service |
| CONTROL_EXECUTOR, |
| Optional.of(mockDownloadMonitor), |
| blockingDownloaderSupplier); |
| |
| int downloadFuturesInFlightCountBefore = downloaderImpl.keyToListenableFuture.size(); |
| |
| ListenableFuture<Void> downloadFuture = |
| downloaderImpl.downloadWithForegroundService(downloadRequest); |
| |
| assertThat(downloaderImpl.keyToListenableFuture).containsKey(destinationFileUri.toString()); |
| |
| assertThat(downloaderImpl.keyToListenableFuture.size() - downloadFuturesInFlightCountBefore) |
| .isEqualTo(1); |
| |
| downloaderImpl.cancelForegroundDownload(destinationFileUri.toString()); |
| assertTrue(downloadFuture.isCancelled()); |
| |
| // The completed download is removed from the uriToListenableFuture Map. |
| assertThat(downloaderImpl.keyToListenableFuture) |
| .doesNotContainKey(destinationFileUri.toString()); |
| assertThat(downloaderImpl.keyToListenableFuture).hasSize(downloadFuturesInFlightCountBefore); |
| |
| // Reset state of blockingFileDownloader to prevent deadlocks |
| blockingFileDownloader.resetState(); |
| } |
| |
| @Test |
| public void cancelListenableFuture() { |
| // Use BlockingFileDownloader to control when the download will finish. |
| BlockingFileDownloader blockingFileDownloader = |
| new BlockingFileDownloader(listeningExecutorService); |
| Supplier<FileDownloader> blockingDownloaderSupplier = () -> blockingFileDownloader; |
| |
| DownloaderImpl downloaderImpl = |
| new DownloaderImpl( |
| context, |
| Optional.of(this.getClass()), // don't need to use the real foreground download service |
| CONTROL_EXECUTOR, |
| Optional.of(mockDownloadMonitor), |
| blockingDownloaderSupplier); |
| |
| ListenableFuture<Void> downloadFuture = |
| downloaderImpl.downloadWithForegroundService(downloadRequest); |
| |
| assertThat(downloaderImpl.keyToListenableFuture).containsKey(destinationFileUri.toString()); |
| |
| downloadFuture.cancel(true); |
| |
| // The completed download is removed from the uriToListenableFuture Map. |
| assertThat(downloaderImpl.keyToListenableFuture) |
| .doesNotContainKey(destinationFileUri.toString()); |
| |
| // Reset state of blockingFileDownloader to prevent deadlocks |
| blockingFileDownloader.resetState(); |
| } |
| } |
