From ee3cc97fd33e15f2cd1043587674fc8b30df8c89 Mon Sep 17 00:00:00 2001 From: Charlie Anderson Date: Thu, 18 Jul 2024 10:55:18 -0400 Subject: [PATCH] [Test Week] unit tests for LauncherRestoreEventLoggerImpl 5 public methods tested No previous testing class Flag: TEST_ONLY Test: unit test Bug: 353303621 Change-Id: I97273e7eebebfa4aac1e7c3db8bf089f3e49f150 --- .../LauncherRestoreEventLoggerImpl.kt | 5 +- .../LauncherRestoreEventLoggerImplTest.kt | 139 ++++++++++++++++++ 2 files changed, 142 insertions(+), 2 deletions(-) create mode 100644 quickstep/tests/multivalentTests/src/com/android/quickstep/LauncherRestoreEventLoggerImplTest.kt diff --git a/quickstep/src/com/android/quickstep/LauncherRestoreEventLoggerImpl.kt b/quickstep/src/com/android/quickstep/LauncherRestoreEventLoggerImpl.kt index 27bd03d4dd..7d22c527d1 100644 --- a/quickstep/src/com/android/quickstep/LauncherRestoreEventLoggerImpl.kt +++ b/quickstep/src/com/android/quickstep/LauncherRestoreEventLoggerImpl.kt @@ -5,6 +5,7 @@ import android.app.backup.BackupRestoreEventLogger import android.app.backup.BackupRestoreEventLogger.BackupRestoreDataType import android.app.backup.BackupRestoreEventLogger.BackupRestoreError import android.content.Context +import androidx.annotation.VisibleForTesting import com.android.launcher3.Flags.enableLauncherBrMetricsFixed import com.android.launcher3.LauncherSettings.Favorites import com.android.launcher3.backuprestore.LauncherRestoreEventLogger @@ -29,8 +30,8 @@ class LauncherRestoreEventLoggerImpl(val context: Context) : LauncherRestoreEven @BackupRestoreDataType private const val DATA_TYPE_APP_PAIR = "app_pair" } - private val restoreEventLogger: BackupRestoreEventLogger = - BackupManager(context).delayedRestoreLogger + @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE) + val restoreEventLogger: BackupRestoreEventLogger = BackupManager(context).delayedRestoreLogger /** * For logging when multiple items of a given data type failed to restore. diff --git a/quickstep/tests/multivalentTests/src/com/android/quickstep/LauncherRestoreEventLoggerImplTest.kt b/quickstep/tests/multivalentTests/src/com/android/quickstep/LauncherRestoreEventLoggerImplTest.kt new file mode 100644 index 0000000000..24f9696437 --- /dev/null +++ b/quickstep/tests/multivalentTests/src/com/android/quickstep/LauncherRestoreEventLoggerImplTest.kt @@ -0,0 +1,139 @@ +package com.android.quickstep + +/* + * Copyright (C) 2024 The Android Open Source Project + * + * 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. + */ + +import android.platform.test.annotations.EnableFlags +import android.platform.test.flag.junit.SetFlagsRule +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.filters.SmallTest +import com.android.launcher3.Flags +import com.android.launcher3.LauncherSettings.Favorites +import com.android.launcher3.util.LauncherModelHelper +import com.android.launcher3.util.LauncherModelHelper.SandboxModelContext +import com.google.common.truth.Truth.assertThat +import org.junit.After +import org.junit.Before +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith + +@SmallTest +@RunWith(AndroidJUnit4::class) +@EnableFlags(Flags.FLAG_ENABLE_LAUNCHER_BR_METRICS_FIXED) +class LauncherRestoreEventLoggerImplTest { + + @get:Rule val setFlagsRule = SetFlagsRule() + + private val mLauncherModelHelper = LauncherModelHelper() + private val mSandboxContext: SandboxModelContext = mLauncherModelHelper.sandboxContext + private lateinit var loggerUnderTest: LauncherRestoreEventLoggerImpl + + @Before + fun setup() { + loggerUnderTest = LauncherRestoreEventLoggerImpl(mSandboxContext) + } + + @After + fun teardown() { + loggerUnderTest.restoreEventLogger.clearData() + mLauncherModelHelper.destroy() + } + + @Test + fun `logLauncherItemsRestoreFailed logs multiple items as failing restore`() { + // Given + val expectedDataType = "application" + val expectedError = "test_failure" + // When + loggerUnderTest.logLauncherItemsRestoreFailed( + dataType = expectedDataType, + count = 5, + error = expectedError + ) + // Then + val actualResult = loggerUnderTest.restoreEventLogger.loggingResults.first() + assertThat(actualResult.dataType).isEqualTo(expectedDataType) + assertThat(actualResult.successCount).isEqualTo(0) + assertThat(actualResult.failCount).isEqualTo(5) + assertThat(actualResult.errors.keys).containsExactly(expectedError) + } + + @Test + fun `logLauncherItemsRestored logs multiple items as restored`() { + // Given + val expectedDataType = "application" + // When + loggerUnderTest.logLauncherItemsRestored(dataType = expectedDataType, count = 5) + // Then + val actualResult = loggerUnderTest.restoreEventLogger.loggingResults.first() + assertThat(actualResult.dataType).isEqualTo(expectedDataType) + assertThat(actualResult.successCount).isEqualTo(5) + assertThat(actualResult.failCount).isEqualTo(0) + assertThat(actualResult.errors.keys).isEmpty() + } + + @Test + fun `logSingleFavoritesItemRestored logs a single Favorites Item as restored`() { + // Given + val expectedDataType = "widget" + // When + loggerUnderTest.logSingleFavoritesItemRestored(favoritesId = Favorites.ITEM_TYPE_APPWIDGET) + // Then + val actualResult = loggerUnderTest.restoreEventLogger.loggingResults.first() + assertThat(actualResult.dataType).isEqualTo(expectedDataType) + assertThat(actualResult.successCount).isEqualTo(1) + assertThat(actualResult.failCount).isEqualTo(0) + assertThat(actualResult.errors.keys).isEmpty() + } + + @Test + fun `logSingleFavoritesItemRestoreFailed logs a single Favorites Item as failing restore`() { + // Given + val expectedDataType = "widget" + val expectedError = "test_failure" + // When + loggerUnderTest.logSingleFavoritesItemRestoreFailed( + favoritesId = Favorites.ITEM_TYPE_APPWIDGET, + error = expectedError + ) + // Then + val actualResult = loggerUnderTest.restoreEventLogger.loggingResults.first() + assertThat(actualResult.dataType).isEqualTo(expectedDataType) + assertThat(actualResult.successCount).isEqualTo(0) + assertThat(actualResult.failCount).isEqualTo(1) + assertThat(actualResult.errors.keys).containsExactly(expectedError) + } + + @Test + fun `logFavoritesItemsRestoreFailed logs multiple Favorites Items as failing restore`() { + // Given + val expectedDataType = "deep_shortcut" + val expectedError = "test_failure" + // When + loggerUnderTest.logFavoritesItemsRestoreFailed( + favoritesId = Favorites.ITEM_TYPE_DEEP_SHORTCUT, + count = 5, + error = expectedError + ) + // Then + val actualResult = loggerUnderTest.restoreEventLogger.loggingResults.first() + assertThat(actualResult.dataType).isEqualTo(expectedDataType) + assertThat(actualResult.successCount).isEqualTo(0) + assertThat(actualResult.failCount).isEqualTo(5) + assertThat(actualResult.errors.keys).containsExactly(expectedError) + } +}