Merge "Test QSTileViewModelImpl" into main (b9977e5f) · Commits · e / os / android_frameworks_base

packages/SystemUI/src/com/android/systemui/qs/tiles/base/viewmodel/QSTileViewModelImpl.kt

+1 −1

Original line number	Diff line number	Diff line
		@@ -116,7 +116,7 @@ class QSTileViewModelImpl<DATA_TYPE>(
		)

		override fun forceUpdate() {
		forceUpdates.tryEmit(Unit)
		tileScope.launch { forceUpdates.emit(Unit) }
		}

		override fun onUserChanged(user: UserHandle) {

packages/SystemUI/tests/src/com/android/systemui/qs/tiles/viewmodel/QSTileViewModelInterfaceComplianceTest.kt→packages/SystemUI/tests/src/com/android/systemui/qs/tiles/viewmodel/QSTileViewModelTest.kt

+202 −0

Original line number	Diff line number	Diff line
		@@ -17,14 +17,15 @@
		package com.android.systemui.qs.tiles.viewmodel

		import android.os.UserHandle
		import android.testing.TestableLooper
		import androidx.test.ext.junit.runners.AndroidJUnit4
		import androidx.test.filters.MediumTest
		import com.android.systemui.SysuiTestCase
		import com.android.systemui.classifier.FalsingManagerFake
		import com.android.systemui.common.shared.model.ContentDescription
		import com.android.systemui.common.shared.model.Icon
		import com.android.systemui.coroutines.collectValues
		import com.android.systemui.qs.tiles.base.analytics.QSTileAnalytics
		import com.android.systemui.qs.tiles.base.interactor.DataUpdateTrigger
		import com.android.systemui.qs.tiles.base.interactor.FakeDisabledByPolicyInteractor
		import com.android.systemui.qs.tiles.base.interactor.FakeQSTileDataInteractor
		import com.android.systemui.qs.tiles.base.interactor.FakeQSTileUserActionInteractor
		@@ -32,8 +33,10 @@ import com.android.systemui.qs.tiles.base.interactor.QSTileDataToStateMapper
		import com.android.systemui.qs.tiles.base.logging.QSTileLogger
		import com.android.systemui.qs.tiles.base.viewmodel.QSTileViewModelImpl
		import com.android.systemui.user.data.repository.FakeUserRepository
		import com.android.systemui.util.mockito.eq
		import com.android.systemui.util.time.FakeSystemClock
		import com.google.common.truth.Truth.assertThat
		import kotlinx.coroutines.ExperimentalCoroutinesApi
		import kotlinx.coroutines.flow.launchIn
		import kotlinx.coroutines.test.StandardTestDispatcher
		import kotlinx.coroutines.test.TestScope
		@@ -43,22 +46,25 @@ import org.junit.Before
		import org.junit.Test
		import org.junit.runner.RunWith
		import org.mockito.Mock
		import org.mockito.Mockito.verify
		import org.mockito.MockitoAnnotations

		// TODO(b/299909368): Add more tests
		@MediumTest
		@RunWith(AndroidJUnit4::class)
		@TestableLooper.RunWithLooper(setAsMainLooper = true)
		class QSTileViewModelInterfaceComplianceTest : SysuiTestCase() {
		@OptIn(ExperimentalCoroutinesApi::class)
		class QSTileViewModelTest : SysuiTestCase() {

		@Mock private lateinit var qsTileLogger: QSTileLogger
		@Mock private lateinit var qsTileAnalytics: QSTileAnalytics

		private val fakeUserRepository = FakeUserRepository()
		private val fakeQSTileDataInteractor = FakeQSTileDataInteractor<Any>()
		private val fakeQSTileUserActionInteractor = FakeQSTileUserActionInteractor<Any>()
		private val fakeDisabledByPolicyInteractor = FakeDisabledByPolicyInteractor()
		private val fakeFalsingManager = FalsingManagerFake()
		private val tileConfig =
		QSTileConfigTestBuilder.build { policy = QSTilePolicy.Restricted("test_restriction") }

		private val userRepository = FakeUserRepository()
		private val tileDataInteractor = FakeQSTileDataInteractor<String>()
		private val tileUserActionInteractor = FakeQSTileUserActionInteractor<String>()
		private val disabledByPolicyInteractor = FakeDisabledByPolicyInteractor()
		private val falsingManager = FalsingManagerFake()

		private val testCoroutineDispatcher = StandardTestDispatcher()
		private val testScope = TestScope(testCoroutineDispatcher)
		@@ -72,40 +78,116 @@ class QSTileViewModelInterfaceComplianceTest : SysuiTestCase() {
		}

		@Test
		fun testDoesntListenStateUntilCreated() =
		fun stateReceivedForTheData() =
		testScope.runTest {
		val testTileData = "test_tile_data"
		val states = collectValues(underTest.state)
		runCurrent()

		tileDataInteractor.emitData(testTileData)
		runCurrent()

		assertThat(states()).isNotEmpty()
		assertThat(states().first().label).isEqualTo(testTileData)
		verify(qsTileLogger).logInitialRequest(eq(tileConfig.tileSpec))
		}

		@Test
		fun doesntListenDataIfStateIsntListened() =
		testScope.runTest {
		assertThat(tileDataInteractor.dataSubscriptionCount.value).isEqualTo(0)

		underTest.state.launchIn(backgroundScope)
		runCurrent()

		assertThat(tileDataInteractor.dataSubscriptionCount.value).isEqualTo(1)
		}

		@Test
		fun doesntListenAvailabilityIfAvailabilityIsntListened() =
		testScope.runTest {
		assertThat(tileDataInteractor.availabilitySubscriptionCount.value).isEqualTo(0)

		underTest.isAvailable.launchIn(backgroundScope)
		runCurrent()

		assertThat(tileDataInteractor.availabilitySubscriptionCount.value).isEqualTo(1)
		}

		@Test
		fun doesntListedDataAfterDestroy() =
		testScope.runTest {
		underTest.state.launchIn(backgroundScope)
		underTest.isAvailable.launchIn(backgroundScope)
		runCurrent()

		underTest.destroy()
		runCurrent()

		assertThat(tileDataInteractor.dataSubscriptionCount.value).isEqualTo(0)
		assertThat(tileDataInteractor.availabilitySubscriptionCount.value).isEqualTo(0)
		}

		@Test
		fun forceUpdateTriggersData() =
		testScope.runTest {
		assertThat(fakeQSTileDataInteractor.dataRequests).isEmpty()
		underTest.state.launchIn(backgroundScope)
		runCurrent()

		assertThat(fakeQSTileDataInteractor.dataRequests).isEmpty()
		underTest.forceUpdate()
		runCurrent()

		assertThat(tileDataInteractor.triggers.last())
		.isInstanceOf(DataUpdateTrigger.ForceUpdate::class.java)
		verify(qsTileLogger).logForceUpdate(eq(tileConfig.tileSpec))
		}

		@Test
		fun userChangeUpdatesData() =
		testScope.runTest {
		underTest.state.launchIn(backgroundScope)
		runCurrent()

		assertThat(fakeQSTileDataInteractor.dataRequests).isNotEmpty()
		assertThat(fakeQSTileDataInteractor.dataRequests.first())
		.isEqualTo(FakeQSTileDataInteractor.DataRequest(UserHandle.of(0)))
		underTest.onUserChanged(USER)
		runCurrent()

		assertThat(tileDataInteractor.dataRequests.last())
		.isEqualTo(FakeQSTileDataInteractor.DataRequest(USER))
		}

		@Test
		fun userChangeUpdatesAvailability() =
		testScope.runTest {
		underTest.isAvailable.launchIn(backgroundScope)
		runCurrent()

		underTest.onUserChanged(USER)
		runCurrent()

		assertThat(tileDataInteractor.availabilityRequests.last())
		.isEqualTo(FakeQSTileDataInteractor.AvailabilityRequest(USER))
		}

		private fun createViewModel(
		scope: TestScope,
		config: QSTileConfig = TEST_QS_TILE_CONFIG,
		config: QSTileConfig = tileConfig,
		): QSTileViewModel =
		QSTileViewModelImpl(
		config,
		{ fakeQSTileUserActionInteractor },
		{ fakeQSTileDataInteractor },
		{ tileUserActionInteractor },
		{ tileDataInteractor },
		{
		object : QSTileDataToStateMapper<Any> {
		override fun map(config: QSTileConfig, data: Any): QSTileState =
		object : QSTileDataToStateMapper<String> {
		override fun map(config: QSTileConfig, data: String): QSTileState =
		QSTileState.build(
		{ Icon.Resource(0, ContentDescription.Resource(0)) },
		""
		data
		) {}
		}
		},
		fakeDisabledByPolicyInteractor,
		fakeUserRepository,
		fakeFalsingManager,
		disabledByPolicyInteractor,
		userRepository,
		falsingManager,
		qsTileAnalytics,
		qsTileLogger,
		FakeSystemClock(),
		@@ -115,6 +197,6 @@ class QSTileViewModelInterfaceComplianceTest : SysuiTestCase() {

		private companion object {

		val TEST_QS_TILE_CONFIG = QSTileConfigTestBuilder.build {}
		val USER = UserHandle.of(1)!!
		}
		}

packages/SystemUI/tests/src/com/android/systemui/qs/tiles/viewmodel/QSTileViewModelUserInputTest.kt

0 → 100644

+194 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2023 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.
		*/

		package com.android.systemui.qs.tiles.viewmodel

		import androidx.test.filters.MediumTest
		import com.android.settingslib.RestrictedLockUtils
		import com.android.systemui.SysuiTestCase
		import com.android.systemui.classifier.FalsingManagerFake
		import com.android.systemui.common.shared.model.ContentDescription
		import com.android.systemui.common.shared.model.Icon
		import com.android.systemui.qs.tiles.base.analytics.QSTileAnalytics
		import com.android.systemui.qs.tiles.base.interactor.DataUpdateTrigger
		import com.android.systemui.qs.tiles.base.interactor.DisabledByPolicyInteractor
		import com.android.systemui.qs.tiles.base.interactor.FakeDisabledByPolicyInteractor
		import com.android.systemui.qs.tiles.base.interactor.FakeQSTileDataInteractor
		import com.android.systemui.qs.tiles.base.interactor.FakeQSTileUserActionInteractor
		import com.android.systemui.qs.tiles.base.interactor.QSTileDataToStateMapper
		import com.android.systemui.qs.tiles.base.logging.QSTileLogger
		import com.android.systemui.qs.tiles.base.viewmodel.QSTileViewModelImpl
		import com.android.systemui.user.data.repository.FakeUserRepository
		import com.android.systemui.util.mockito.any
		import com.android.systemui.util.mockito.eq
		import com.android.systemui.util.time.FakeSystemClock
		import com.google.common.truth.Truth.assertThat
		import kotlinx.coroutines.ExperimentalCoroutinesApi
		import kotlinx.coroutines.flow.launchIn
		import kotlinx.coroutines.test.StandardTestDispatcher
		import kotlinx.coroutines.test.TestScope
		import kotlinx.coroutines.test.runCurrent
		import kotlinx.coroutines.test.runTest
		import org.junit.Before
		import org.junit.Test
		import org.junit.runner.RunWith
		import org.junit.runners.Parameterized
		import org.junit.runners.Parameterized.Parameter
		import org.mockito.Mock
		import org.mockito.Mockito.never
		import org.mockito.Mockito.verify
		import org.mockito.MockitoAnnotations

		/** Tests all possible [QSTileUserAction]s. If you need */
		@MediumTest
		@RunWith(Parameterized::class)
		@OptIn(ExperimentalCoroutinesApi::class)
		class QSTileViewModelUserInputTest : SysuiTestCase() {

		@Mock private lateinit var qsTileLogger: QSTileLogger
		@Mock private lateinit var qsTileAnalytics: QSTileAnalytics

		@Parameter lateinit var userAction: QSTileUserAction

		private val tileConfig =
		QSTileConfigTestBuilder.build { policy = QSTilePolicy.Restricted("test_restriction") }

		private val userRepository = FakeUserRepository()
		private val tileDataInteractor = FakeQSTileDataInteractor<String>()
		private val tileUserActionInteractor = FakeQSTileUserActionInteractor<String>()
		private val disabledByPolicyInteractor = FakeDisabledByPolicyInteractor()
		private val falsingManager = FalsingManagerFake()

		private val testCoroutineDispatcher = StandardTestDispatcher()
		private val testScope = TestScope(testCoroutineDispatcher)

		private lateinit var underTest: QSTileViewModel

		@Before
		fun setup() {
		MockitoAnnotations.initMocks(this)
		underTest = createViewModel(testScope)
		}

		@Test
		fun userInputTriggersData() =
		testScope.runTest {
		tileDataInteractor.emitData("initial_data")
		underTest.state.launchIn(backgroundScope)
		runCurrent()

		underTest.onActionPerformed(userAction)
		runCurrent()

		assertThat(tileDataInteractor.triggers.last())
		.isInstanceOf(DataUpdateTrigger.UserInput::class.java)
		verify(qsTileLogger)
		.logUserAction(eq(userAction), eq(tileConfig.tileSpec), eq(true), eq(true))
		verify(qsTileLogger)
		.logUserActionPipeline(
		eq(tileConfig.tileSpec),
		eq(userAction),
		any(),
		eq("initial_data")
		)
		verify(qsTileAnalytics).trackUserAction(eq(tileConfig), eq(userAction))
		}

		@Test
		fun disabledByPolicyUserInputIsSkipped() =
		testScope.runTest {
		underTest.state.launchIn(backgroundScope)
		disabledByPolicyInteractor.policyResult =
		DisabledByPolicyInteractor.PolicyResult.TileDisabled(
		RestrictedLockUtils.EnforcedAdmin()
		)
		runCurrent()

		underTest.onActionPerformed(userAction)
		runCurrent()

		assertThat(tileDataInteractor.triggers.last())
		.isNotInstanceOf(DataUpdateTrigger.UserInput::class.java)
		verify(qsTileLogger)
		.logUserActionRejectedByPolicy(eq(userAction), eq(tileConfig.tileSpec))
		verify(qsTileAnalytics, never()).trackUserAction(any(), any())
		}

		@Test
		fun falsedUserInputIsSkipped() =
		testScope.runTest {
		underTest.state.launchIn(backgroundScope)
		falsingManager.setFalseLongTap(true)
		falsingManager.setFalseTap(true)
		runCurrent()

		underTest.onActionPerformed(userAction)
		runCurrent()

		assertThat(tileDataInteractor.triggers.last())
		.isNotInstanceOf(DataUpdateTrigger.UserInput::class.java)
		verify(qsTileLogger)
		.logUserActionRejectedByFalsing(eq(userAction), eq(tileConfig.tileSpec))
		verify(qsTileAnalytics, never()).trackUserAction(any(), any())
		}

		@Test
		fun userInputIsThrottled() =
		testScope.runTest {
		val inputCount = 100
		underTest.state.launchIn(backgroundScope)

		repeat(inputCount) { underTest.onActionPerformed(userAction) }
		runCurrent()

		assertThat(tileDataInteractor.triggers.size).isLessThan(inputCount)
		}

		private fun createViewModel(scope: TestScope): QSTileViewModel =
		QSTileViewModelImpl(
		tileConfig,
		{ tileUserActionInteractor },
		{ tileDataInteractor },
		{
		object : QSTileDataToStateMapper<String> {
		override fun map(config: QSTileConfig, data: String): QSTileState =
		QSTileState.build(
		{ Icon.Resource(0, ContentDescription.Resource(0)) },
		data
		) {}
		}
		},
		disabledByPolicyInteractor,
		userRepository,
		falsingManager,
		qsTileAnalytics,
		qsTileLogger,
		FakeSystemClock(),
		testCoroutineDispatcher,
		scope.backgroundScope,
		)

		companion object {

		@JvmStatic
		@Parameterized.Parameters
		fun data(): Iterable<QSTileUserAction> =
		listOf(
		QSTileUserAction.Click(null),
		QSTileUserAction.LongClick(null),
		)
		}
		}

packages/SystemUI/tests/utils/src/com/android/systemui/qs/tiles/base/interactor/FakeDisabledByPolicyInteractor.kt

+5 −2

Original line number	Diff line number	Diff line
		@@ -20,7 +20,6 @@ import android.os.UserHandle

		class FakeDisabledByPolicyInteractor : DisabledByPolicyInteractor {

		var handleResult: Boolean = false
		var policyResult: DisabledByPolicyInteractor.PolicyResult =
		DisabledByPolicyInteractor.PolicyResult.TileEnabled

		@@ -31,5 +30,9 @@ class FakeDisabledByPolicyInteractor : DisabledByPolicyInteractor {

		override fun handlePolicyResult(
		policyResult: DisabledByPolicyInteractor.PolicyResult
		): Boolean = handleResult
		): Boolean =
		when (policyResult) {
		is DisabledByPolicyInteractor.PolicyResult.TileEnabled -> false
		is DisabledByPolicyInteractor.PolicyResult.TileDisabled -> true
		}
		}

packages/SystemUI/tests/utils/src/com/android/systemui/qs/tiles/base/interactor/FakeQSTileDataInteractor.kt

+16 −8

Original line number	Diff line number	Diff line
		@@ -17,16 +17,21 @@
		package com.android.systemui.qs.tiles.base.interactor

		import android.os.UserHandle
		import javax.annotation.CheckReturnValue
		import kotlinx.coroutines.flow.Flow
		import kotlinx.coroutines.flow.MutableSharedFlow
		import kotlinx.coroutines.flow.flatMapLatest

		class FakeQSTileDataInteractor<T>(
		private val dataFlow: MutableSharedFlow<T> = MutableSharedFlow(replay = Int.MAX_VALUE),
		private val availabilityFlow: MutableSharedFlow<Boolean> =
		MutableSharedFlow(replay = Int.MAX_VALUE),
		) : QSTileDataInteractor<T> {
		class FakeQSTileDataInteractor<T> : QSTileDataInteractor<T> {

		private val dataFlow: MutableSharedFlow<T> = MutableSharedFlow(replay = 1)
		val dataSubscriptionCount
		get() = dataFlow.subscriptionCount
		private val availabilityFlow: MutableSharedFlow<Boolean> = MutableSharedFlow(replay = 1)
		val availabilitySubscriptionCount
		get() = availabilityFlow.subscriptionCount

		private val mutableTriggers = mutableListOf<DataUpdateTrigger>()
		val triggers: List<DataUpdateTrigger> = mutableTriggers

		private val mutableDataRequests = mutableListOf<DataRequest>()
		val dataRequests: List<DataRequest> = mutableDataRequests
		@@ -34,14 +39,17 @@ class FakeQSTileDataInteractor<T>(
		private val mutableAvailabilityRequests = mutableListOf<AvailabilityRequest>()
		val availabilityRequests: List<AvailabilityRequest> = mutableAvailabilityRequests

		@CheckReturnValue fun emitData(data: T): Boolean = dataFlow.tryEmit(data)
		suspend fun emitData(data: T): Unit = dataFlow.emit(data)

		fun tryEmitAvailability(isAvailable: Boolean): Boolean = availabilityFlow.tryEmit(isAvailable)
		suspend fun emitAvailability(isAvailable: Boolean) = availabilityFlow.emit(isAvailable)

		override fun tileData(user: UserHandle, triggers: Flow<DataUpdateTrigger>): Flow<T> {
		mutableDataRequests.add(DataRequest(user))
		return triggers.flatMapLatest { dataFlow }
		return triggers.flatMapLatest {
		mutableTriggers.add(it)
		dataFlow
		}
		}

		override fun availability(user: UserHandle): Flow<Boolean> {