From fa89fa1f97692ca1d4d52ea87a587c79d104bbbb Mon Sep 17 00:00:00 2001 From: Chaohui Wang Date: Mon, 11 Mar 2024 12:31:21 +0800 Subject: New RestrictedTwoTargetSwitchPreference Bug: 329000499 Test: manual - on Mobile Settings Test: unit tests Change-Id: I6d50b545bde33b5b54658fe295798f64048ea3d8 --- .../widget/preference/TwoTargetButtonPreference.kt | 2 +- .../spa/widget/preference/TwoTargetPreference.kt | 6 +- .../widget/preference/TwoTargetSwitchPreference.kt | 6 +- .../preference/TwoTargetSwitchPreferenceTest.kt | 69 ++++--- .../template/app/AppListTwoTargetSwitchItem.kt | 2 +- .../template/preference/RestrictedPreference.kt | 34 ++-- .../preference/RestrictedSwitchPreferenceModel.kt | 29 ++- .../RestrictedTwoTargetSwitchPreference.kt | 70 ++++++++ .../RestrictedTwoTargetSwitchPreferenceTest.kt | 198 +++++++++++++++++++++ 9 files changed, 359 insertions(+), 57 deletions(-) create mode 100644 packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/preference/RestrictedTwoTargetSwitchPreference.kt create mode 100644 packages/SettingsLib/SpaPrivileged/tests/src/com/android/settingslib/spaprivileged/template/preference/RestrictedTwoTargetSwitchPreferenceTest.kt diff --git a/packages/SettingsLib/Spa/spa/src/com/android/settingslib/spa/widget/preference/TwoTargetButtonPreference.kt b/packages/SettingsLib/Spa/spa/src/com/android/settingslib/spa/widget/preference/TwoTargetButtonPreference.kt index 986602394b3b..3f74ed5e2814 100644 --- a/packages/SettingsLib/Spa/spa/src/com/android/settingslib/spa/widget/preference/TwoTargetButtonPreference.kt +++ b/packages/SettingsLib/Spa/spa/src/com/android/settingslib/spa/widget/preference/TwoTargetButtonPreference.kt @@ -36,7 +36,7 @@ fun TwoTargetButtonPreference( TwoTargetPreference( title = title, summary = summary, - onClick = onClick, + primaryOnClick = onClick, icon = icon, ) { IconButton(onClick = onButtonClick) { diff --git a/packages/SettingsLib/Spa/spa/src/com/android/settingslib/spa/widget/preference/TwoTargetPreference.kt b/packages/SettingsLib/Spa/spa/src/com/android/settingslib/spa/widget/preference/TwoTargetPreference.kt index 3216e37b5db4..3f688045fa19 100644 --- a/packages/SettingsLib/Spa/spa/src/com/android/settingslib/spa/widget/preference/TwoTargetPreference.kt +++ b/packages/SettingsLib/Spa/spa/src/com/android/settingslib/spa/widget/preference/TwoTargetPreference.kt @@ -34,7 +34,8 @@ import com.android.settingslib.spa.framework.theme.divider internal fun TwoTargetPreference( title: String, summary: () -> String, - onClick: () -> Unit, + primaryEnabled: () -> Boolean = { true }, + primaryOnClick: (() -> Unit)?, icon: @Composable (() -> Unit)? = null, widget: @Composable () -> Unit, ) { @@ -50,7 +51,8 @@ internal fun TwoTargetPreference( override val title = title override val summary = summary override val icon = icon - override val onClick = onClick + override val enabled = primaryEnabled + override val onClick = primaryOnClick } ) } diff --git a/packages/SettingsLib/Spa/spa/src/com/android/settingslib/spa/widget/preference/TwoTargetSwitchPreference.kt b/packages/SettingsLib/Spa/spa/src/com/android/settingslib/spa/widget/preference/TwoTargetSwitchPreference.kt index 7eed74588fb2..8b546b4de069 100644 --- a/packages/SettingsLib/Spa/spa/src/com/android/settingslib/spa/widget/preference/TwoTargetSwitchPreference.kt +++ b/packages/SettingsLib/Spa/spa/src/com/android/settingslib/spa/widget/preference/TwoTargetSwitchPreference.kt @@ -24,13 +24,15 @@ import com.android.settingslib.spa.widget.ui.SettingsSwitch fun TwoTargetSwitchPreference( model: SwitchPreferenceModel, icon: @Composable (() -> Unit)? = null, - onClick: () -> Unit, + primaryEnabled: () -> Boolean = { true }, + primaryOnClick: (() -> Unit)?, ) { EntryHighlight { TwoTargetPreference( title = model.title, summary = model.summary, - onClick = onClick, + primaryEnabled = primaryEnabled, + primaryOnClick = primaryOnClick, icon = icon, ) { SettingsSwitch( diff --git a/packages/SettingsLib/Spa/tests/src/com/android/settingslib/spa/widget/preference/TwoTargetSwitchPreferenceTest.kt b/packages/SettingsLib/Spa/tests/src/com/android/settingslib/spa/widget/preference/TwoTargetSwitchPreferenceTest.kt index 3455851a10bb..0acf2878bf0c 100644 --- a/packages/SettingsLib/Spa/tests/src/com/android/settingslib/spa/widget/preference/TwoTargetSwitchPreferenceTest.kt +++ b/packages/SettingsLib/Spa/tests/src/com/android/settingslib/spa/widget/preference/TwoTargetSwitchPreferenceTest.kt @@ -23,6 +23,7 @@ import androidx.compose.runtime.remember import androidx.compose.runtime.saveable.rememberSaveable import androidx.compose.runtime.setValue import androidx.compose.ui.test.assertIsDisplayed +import androidx.compose.ui.test.assertIsNotEnabled import androidx.compose.ui.test.assertIsOff import androidx.compose.ui.test.assertIsOn import androidx.compose.ui.test.isToggleable @@ -46,7 +47,7 @@ class TwoTargetSwitchPreferenceTest { TestTwoTargetSwitchPreference(changeable = true) } - composeTestRule.onNodeWithText("TwoTargetSwitchPreference").assertIsDisplayed() + composeTestRule.onNodeWithText(TITLE).assertIsDisplayed() } @Test @@ -79,7 +80,7 @@ class TwoTargetSwitchPreferenceTest { } @Test - fun clickable_canBeClick() { + fun clickable_primaryEnabled_canBeClick() { var clicked = false composeTestRule.setContent { TestTwoTargetSwitchPreference(changeable = false) { @@ -87,26 +88,54 @@ class TwoTargetSwitchPreferenceTest { } } - composeTestRule.onNodeWithText("TwoTargetSwitchPreference").performClick() + composeTestRule.onNodeWithText(TITLE).performClick() assertThat(clicked).isTrue() } -} -@Composable -private fun TestTwoTargetSwitchPreference( - changeable: Boolean, - onClick: () -> Unit = {}, -) { - var checked by rememberSaveable { mutableStateOf(false) } - TwoTargetSwitchPreference( - model = remember { - object : SwitchPreferenceModel { - override val title = "TwoTargetSwitchPreference" - override val checked = { checked } - override val changeable = { changeable } - override val onCheckedChange = { newChecked: Boolean -> checked = newChecked } + @Test + fun clickable_primaryNotEnabled_assertIsNotEnabled() { + composeTestRule.setContent { + TestTwoTargetSwitchPreference(changeable = false, primaryEnabled = false) + } + + composeTestRule.onNodeWithText(TITLE).assertIsNotEnabled() + } + + @Test + fun clickable_primaryNotEnabled_canNotBeClick() { + var clicked = false + composeTestRule.setContent { + TestTwoTargetSwitchPreference(changeable = false, primaryEnabled = false) { + clicked = true } - }, - onClick = onClick, - ) + } + + composeTestRule.onNodeWithText(TITLE).performClick() + assertThat(clicked).isFalse() + } + + @Composable + private fun TestTwoTargetSwitchPreference( + changeable: Boolean, + primaryEnabled: Boolean = true, + primaryOnClick: () -> Unit = {}, + ) { + var checked by rememberSaveable { mutableStateOf(false) } + TwoTargetSwitchPreference( + model = remember { + object : SwitchPreferenceModel { + override val title = TITLE + override val checked = { checked } + override val changeable = { changeable } + override val onCheckedChange = { newChecked: Boolean -> checked = newChecked } + } + }, + primaryEnabled = { primaryEnabled }, + primaryOnClick = primaryOnClick, + ) + } + + private companion object { + const val TITLE = "Title" + } } diff --git a/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/app/AppListTwoTargetSwitchItem.kt b/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/app/AppListTwoTargetSwitchItem.kt index bea14c360238..5c2d7701fd6f 100644 --- a/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/app/AppListTwoTargetSwitchItem.kt +++ b/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/app/AppListTwoTargetSwitchItem.kt @@ -38,6 +38,6 @@ fun AppListItemModel.AppListTwoTargetSwitchItem( override val onCheckedChange = onCheckedChange }, icon = { AppIcon(record.app, SettingsDimension.appIconItemSize) }, - onClick = onClick, + primaryOnClick = onClick, ) } diff --git a/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/preference/RestrictedPreference.kt b/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/preference/RestrictedPreference.kt index ac85dd4249f6..389b3c1b4be4 100644 --- a/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/preference/RestrictedPreference.kt +++ b/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/preference/RestrictedPreference.kt @@ -54,14 +54,27 @@ internal fun RestrictedPreference( return } val restrictedMode = restrictionsProviderFactory.rememberRestrictedMode(restrictions).value - val restrictedSwitchModel = remember(restrictedMode) { + val restrictedModel = remember(restrictedMode) { RestrictedPreferenceModel(model, restrictedMode) } - restrictedSwitchModel.RestrictionWrapper { - Preference(restrictedSwitchModel) + restrictedModel.RestrictionWrapper { + Preference(restrictedModel) } } +internal fun RestrictedMode?.restrictEnabled(enabled: () -> Boolean) = when (this) { + NoRestricted -> enabled + else -> ({ false }) +} + +internal fun RestrictedMode?.restrictOnClick(onClick: T): T? = when (this) { + NoRestricted -> onClick + // Need to passthrough onClick for clickable semantics, although since enabled is false so + // this will not be called. + BaseUserRestricted -> onClick + else -> null +} + private class RestrictedPreferenceModel( model: PreferenceModel, private val restrictedMode: RestrictedMode?, @@ -69,19 +82,8 @@ private class RestrictedPreferenceModel( override val title = model.title override val summary = model.summary override val icon = model.icon - - override val enabled = when (restrictedMode) { - NoRestricted -> model.enabled - else -> ({ false }) - } - - override val onClick = when (restrictedMode) { - NoRestricted -> model.onClick - // Need to passthrough onClick for clickable semantics, although since enabled is false so - // this will not be called. - BaseUserRestricted -> model.onClick - else -> null - } + override val enabled = restrictedMode.restrictEnabled(model.enabled) + override val onClick = restrictedMode.restrictOnClick(model.onClick) @Composable fun RestrictionWrapper(content: @Composable () -> Unit) { diff --git a/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/preference/RestrictedSwitchPreferenceModel.kt b/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/preference/RestrictedSwitchPreferenceModel.kt index aba3460fc1b9..5dfecb0b7bd4 100644 --- a/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/preference/RestrictedSwitchPreferenceModel.kt +++ b/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/preference/RestrictedSwitchPreferenceModel.kt @@ -60,18 +60,9 @@ internal class RestrictedSwitchPreferenceModel( is BlockedByEcm -> model.checked } - override val changeable = if (restrictedMode is NoRestricted) model.changeable else ({ false }) - - override val onCheckedChange = when (restrictedMode) { - null -> null - is NoRestricted -> model.onCheckedChange - // Need to passthrough onCheckedChange for toggleable semantics, although since changeable - // is false so this will not be called. - is BaseUserRestricted -> model.onCheckedChange - // Pass null since semantics ToggleableState is provided in RestrictionWrapper. - is BlockedByAdmin -> null - is BlockedByEcm -> null - } + override val changeable = restrictedMode.restrictEnabled(model.changeable) + + override val onCheckedChange = restrictedMode.restrictOnClick(model.onCheckedChange) @Composable fun RestrictionWrapper(content: @Composable () -> Unit) { @@ -116,13 +107,12 @@ internal class RestrictedSwitchPreferenceModel( companion object { @Composable - fun RestrictionsProviderFactory.RestrictedSwitchWrapper( + fun RestrictedSwitchWrapper( model: SwitchPreferenceModel, - restrictions: Restrictions, + restrictedMode: RestrictedMode?, content: @Composable (SwitchPreferenceModel) -> Unit, ) { val context = LocalContext.current - val restrictedMode = rememberRestrictedMode(restrictions).value val restrictedSwitchPreferenceModel = remember(restrictedMode) { RestrictedSwitchPreferenceModel(context, model, restrictedMode) } @@ -131,6 +121,15 @@ internal class RestrictedSwitchPreferenceModel( } } + @Composable + fun RestrictionsProviderFactory.RestrictedSwitchWrapper( + model: SwitchPreferenceModel, + restrictions: Restrictions, + content: @Composable (SwitchPreferenceModel) -> Unit, + ) { + RestrictedSwitchWrapper(model, rememberRestrictedMode(restrictions).value, content) + } + fun getSummary( context: Context, restrictedModeSupplier: () -> RestrictedMode?, diff --git a/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/preference/RestrictedTwoTargetSwitchPreference.kt b/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/preference/RestrictedTwoTargetSwitchPreference.kt new file mode 100644 index 000000000000..e100773b2358 --- /dev/null +++ b/packages/SettingsLib/SpaPrivileged/src/com/android/settingslib/spaprivileged/template/preference/RestrictedTwoTargetSwitchPreference.kt @@ -0,0 +1,70 @@ +/* + * 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. + */ + +package com.android.settingslib.spaprivileged.template.preference + +import androidx.annotation.VisibleForTesting +import androidx.compose.runtime.Composable +import com.android.settingslib.spa.widget.preference.SwitchPreferenceModel +import com.android.settingslib.spa.widget.preference.TwoTargetSwitchPreference +import com.android.settingslib.spaprivileged.model.enterprise.Restrictions +import com.android.settingslib.spaprivileged.model.enterprise.RestrictionsProviderFactory +import com.android.settingslib.spaprivileged.model.enterprise.RestrictionsProviderImpl +import com.android.settingslib.spaprivileged.model.enterprise.rememberRestrictedMode +import com.android.settingslib.spaprivileged.template.preference.RestrictedSwitchPreferenceModel.Companion.RestrictedSwitchWrapper + +@Composable +fun RestrictedTwoTargetSwitchPreference( + model: SwitchPreferenceModel, + icon: @Composable (() -> Unit)? = null, + restrictions: Restrictions, + primaryEnabled: () -> Boolean = { true }, + primaryOnClick: (() -> Unit)?, +) { + RestrictedTwoTargetSwitchPreference( + model = model, + icon = icon, + primaryEnabled = primaryEnabled, + primaryOnClick = primaryOnClick, + restrictions = restrictions, + restrictionsProviderFactory = ::RestrictionsProviderImpl, + ) +} + +@VisibleForTesting +@Composable +internal fun RestrictedTwoTargetSwitchPreference( + model: SwitchPreferenceModel, + icon: @Composable (() -> Unit)? = null, + primaryEnabled: () -> Boolean = { true }, + primaryOnClick: (() -> Unit)?, + restrictions: Restrictions, + restrictionsProviderFactory: RestrictionsProviderFactory, +) { + if (restrictions.isEmpty()) { + TwoTargetSwitchPreference(model, icon, primaryEnabled, primaryOnClick) + return + } + val restrictedMode = restrictionsProviderFactory.rememberRestrictedMode(restrictions).value + RestrictedSwitchWrapper(model, restrictedMode) { restrictedModel -> + TwoTargetSwitchPreference( + model = restrictedModel, + icon = icon, + primaryEnabled = restrictedMode.restrictEnabled(primaryEnabled), + primaryOnClick = restrictedMode.restrictOnClick(primaryOnClick), + ) + } +} diff --git a/packages/SettingsLib/SpaPrivileged/tests/src/com/android/settingslib/spaprivileged/template/preference/RestrictedTwoTargetSwitchPreferenceTest.kt b/packages/SettingsLib/SpaPrivileged/tests/src/com/android/settingslib/spaprivileged/template/preference/RestrictedTwoTargetSwitchPreferenceTest.kt new file mode 100644 index 000000000000..bdff89f6d69b --- /dev/null +++ b/packages/SettingsLib/SpaPrivileged/tests/src/com/android/settingslib/spaprivileged/template/preference/RestrictedTwoTargetSwitchPreferenceTest.kt @@ -0,0 +1,198 @@ +/* + * 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. + */ + +package com.android.settingslib.spaprivileged.template.preference + +import androidx.compose.runtime.mutableStateOf +import androidx.compose.ui.test.assertIsDisplayed +import androidx.compose.ui.test.assertIsEnabled +import androidx.compose.ui.test.assertIsNotEnabled +import androidx.compose.ui.test.isOff +import androidx.compose.ui.test.isOn +import androidx.compose.ui.test.isToggleable +import androidx.compose.ui.test.junit4.createComposeRule +import androidx.compose.ui.test.onNodeWithText +import androidx.compose.ui.test.onRoot +import androidx.compose.ui.test.performClick +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.android.settingslib.spa.widget.preference.SwitchPreferenceModel +import com.android.settingslib.spaprivileged.model.enterprise.BaseUserRestricted +import com.android.settingslib.spaprivileged.model.enterprise.NoRestricted +import com.android.settingslib.spaprivileged.model.enterprise.Restrictions +import com.android.settingslib.spaprivileged.tests.testutils.FakeBlockedByAdmin +import com.android.settingslib.spaprivileged.tests.testutils.FakeBlockedByEcm +import com.android.settingslib.spaprivileged.tests.testutils.FakeRestrictionsProvider +import com.google.common.truth.Truth.assertThat +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith + +@RunWith(AndroidJUnit4::class) +class RestrictedTwoTargetSwitchPreferenceTest { + @get:Rule + val composeTestRule = createComposeRule() + + private val fakeBlockedByAdmin = FakeBlockedByAdmin() + private val fakeBlockedByEcm = FakeBlockedByEcm() + + private val fakeRestrictionsProvider = FakeRestrictionsProvider() + + private val switchPreferenceModel = object : SwitchPreferenceModel { + override val title = TITLE + private val checkedState = mutableStateOf(true) + override val checked = { checkedState.value } + override val onCheckedChange: (Boolean) -> Unit = { checkedState.value = it } + } + + @Test + fun whenRestrictionsKeysIsEmpty_enabled() { + val restrictions = Restrictions(userId = USER_ID, keys = emptyList()) + + setContent(restrictions) + + composeTestRule.onNodeWithText(TITLE).assertIsDisplayed().assertIsEnabled() + composeTestRule.onNode(isOn()).assertIsDisplayed() + } + + @Test + fun whenRestrictionsKeysIsEmpty_toggleable() { + val restrictions = Restrictions(userId = USER_ID, keys = emptyList()) + + setContent(restrictions) + composeTestRule.onNode(isToggleable()).performClick() + + composeTestRule.onNode(isOff()).assertIsDisplayed() + } + + @Test + fun whenNoRestricted_enabled() { + val restrictions = Restrictions(userId = USER_ID, keys = listOf(RESTRICTION_KEY)) + fakeRestrictionsProvider.restrictedMode = NoRestricted + + setContent(restrictions) + + composeTestRule.onNodeWithText(TITLE).assertIsDisplayed().assertIsEnabled() + composeTestRule.onNode(isOn()).assertIsDisplayed().assertIsEnabled() + } + + @Test + fun whenNoRestricted_toggleable() { + val restrictions = Restrictions(userId = USER_ID, keys = listOf(RESTRICTION_KEY)) + fakeRestrictionsProvider.restrictedMode = NoRestricted + + setContent(restrictions) + composeTestRule.onNode(isToggleable()).performClick() + + composeTestRule.onNode(isOff()).assertIsDisplayed() + } + + @Test + fun whenBaseUserRestricted_disabled() { + val restrictions = Restrictions(userId = USER_ID, keys = listOf(RESTRICTION_KEY)) + fakeRestrictionsProvider.restrictedMode = BaseUserRestricted + + setContent(restrictions) + + composeTestRule.onNodeWithText(TITLE).assertIsDisplayed().assertIsNotEnabled() + composeTestRule.onNode(isOff()).assertIsDisplayed() + } + + @Test + fun whenBaseUserRestricted_notToggleable() { + val restrictions = Restrictions(userId = USER_ID, keys = listOf(RESTRICTION_KEY)) + fakeRestrictionsProvider.restrictedMode = BaseUserRestricted + + setContent(restrictions) + composeTestRule.onNode(isToggleable()).performClick() + + composeTestRule.onNode(isOff()).assertIsDisplayed() + } + + @Test + fun whenBlockedByAdmin_disabled() { + val restrictions = Restrictions(userId = USER_ID, keys = listOf(RESTRICTION_KEY)) + fakeRestrictionsProvider.restrictedMode = fakeBlockedByAdmin + + setContent(restrictions) + + composeTestRule.onNodeWithText(TITLE).assertIsDisplayed().assertIsEnabled() + composeTestRule.onNodeWithText(FakeBlockedByAdmin.SUMMARY).assertIsDisplayed() + composeTestRule.onNode(isOn()).assertIsDisplayed().assertIsEnabled() + } + + @Test + fun whenBlockedByAdmin_clickPrimary() { + val restrictions = Restrictions(userId = USER_ID, keys = listOf(RESTRICTION_KEY)) + fakeRestrictionsProvider.restrictedMode = fakeBlockedByAdmin + + setContent(restrictions) + composeTestRule.onNodeWithText(TITLE).performClick() + + assertThat(fakeBlockedByAdmin.sendShowAdminSupportDetailsIntentIsCalled).isTrue() + } + + @Test + fun whenBlockedByAdmin_clickSwitch() { + val restrictions = Restrictions(userId = USER_ID, keys = listOf(RESTRICTION_KEY)) + fakeRestrictionsProvider.restrictedMode = fakeBlockedByAdmin + + setContent(restrictions) + composeTestRule.onNode(isToggleable()).performClick() + + assertThat(fakeBlockedByAdmin.sendShowAdminSupportDetailsIntentIsCalled).isTrue() + } + + @Test + fun whenBlockedByEcm_disabled() { + val restrictions = Restrictions(userId = USER_ID, keys = listOf(RESTRICTION_KEY)) + fakeRestrictionsProvider.restrictedMode = fakeBlockedByEcm + + setContent(restrictions) + + composeTestRule.onNodeWithText(TITLE).assertIsDisplayed().assertIsEnabled() + composeTestRule.onNodeWithText(FakeBlockedByEcm.SUMMARY).assertIsDisplayed() + composeTestRule.onNode(isOn()).assertIsDisplayed() + } + + @Test + fun whenBlockedByEcm_click() { + val restrictions = Restrictions(userId = USER_ID, keys = listOf(RESTRICTION_KEY)) + fakeRestrictionsProvider.restrictedMode = fakeBlockedByEcm + + setContent(restrictions) + composeTestRule.onRoot().performClick() + + assertThat(fakeBlockedByEcm.showRestrictedSettingsDetailsIsCalled).isTrue() + } + + private fun setContent(restrictions: Restrictions, primaryOnClick: (() -> Unit)? = {}) { + composeTestRule.setContent { + RestrictedTwoTargetSwitchPreference( + model = switchPreferenceModel, + primaryOnClick = primaryOnClick, + restrictions = restrictions, + ) { _, _ -> + fakeRestrictionsProvider + } + } + } + + private companion object { + const val TITLE = "Title" + const val USER_ID = 0 + const val RESTRICTION_KEY = "restriction_key" + } +} -- cgit v1.2.3-59-g8ed1b