Handle errors when updating push rules

library/ui-strings/src/main/res/values/strings.xml

@@ -862,6 +862,8 @@
     <string name="settings_notification_keyword_contains_dot">Keywords cannot start with \'.\'</string>
     <string name="settings_notification_keyword_contains_invalid_character">Keywords cannot contain \'%s\'</string>
 
+    <string name="settings_notification_error_on_update">An error occurred when updating your notification preferences. Please try again.</string>
+
     <string name="settings_notification_troubleshoot">Troubleshoot Notifications</string>
     <string name="settings_troubleshoot_diagnostic">Troubleshooting diagnostics</string>
     <string name="settings_troubleshoot_diagnostic_run_button_title">Run Tests</string>

vector/src/main/java/im/vector/app/core/preference/VectorCheckboxPreference.kt

@@ -32,6 +32,8 @@ class VectorCheckboxPreference : CheckBoxPreference {
 
     constructor(context: Context) : super(context)
 
+    var summaryTextColor: Int? = null
+
     init {
         // Set to false to remove the space when there is no icon
         isIconSpaceReserved = true
@@ -42,4 +44,9 @@ class VectorCheckboxPreference : CheckBoxPreference {
         (holder.findViewById(android.R.id.title) as? TextView)?.isSingleLine = false
         super.onBindViewHolder(holder)
     }
+
+    override fun syncSummaryView(holder: PreferenceViewHolder) {
+        super.syncSummaryView(holder)
+        summaryTextColor?.let { (holder.findViewById(android.R.id.summary) as? TextView)?.setTextColor(it) }
+    }
 }

vector/src/main/java/im/vector/app/core/session/ConfigureAndStartSessionUseCase.kt

@@ -52,7 +52,7 @@ class ConfigureAndStartSessionUseCase @Inject constructor(
         updateMatrixClientInfoIfNeeded(session)
         createNotificationSettingsAccountDataIfNeeded(session)
         notificationsSettingUpdater.onSessionStarted(session)
-        pushRulesUpdater.onSessionStarted(session)
+//        pushRulesUpdater.onSessionStarted(session)
     }
 
     private fun updateMatrixClientInfoIfNeeded(session: Session) {

vector/src/main/java/im/vector/app/features/settings/notifications/PushRuleDefinitions.kt

@@ -42,8 +42,7 @@ fun getStandardAction(ruleId: String, index: NotificationIndex): StandardActions
         RuleIds.RULE_ID_POLL_START_ONE_TO_ONE,
         RuleIds.RULE_ID_POLL_START_ONE_TO_ONE_UNSTABLE,
         RuleIds.RULE_ID_POLL_END_ONE_TO_ONE,
-        RuleIds.RULE_ID_POLL_END_ONE_TO_ONE_UNSTABLE,
+        RuleIds.RULE_ID_POLL_END_ONE_TO_ONE_UNSTABLE ->
-        ->
             when (index) {
                 NotificationIndex.OFF -> StandardActions.DontNotify
                 NotificationIndex.SILENT -> StandardActions.Notify

vector/src/main/java/im/vector/app/features/settings/notifications/VectorSettingsPushRuleNotificationFragment.kt

@@ -21,33 +21,35 @@ import android.view.View
 import androidx.preference.Preference
 import com.airbnb.mvrx.fragmentViewModel
 import com.airbnb.mvrx.withState
+import im.vector.app.R
 import im.vector.app.core.preference.VectorCheckboxPreference
 import im.vector.app.features.settings.VectorSettingsBaseFragment
+import im.vector.app.features.themes.ThemeUtils
 
 abstract class VectorSettingsPushRuleNotificationFragment :
         VectorSettingsBaseFragment() {
 
-    private val viewModel: VectorSettingsPushRuleNotificationViewModel by fragmentViewModel()
+    protected val viewModel: VectorSettingsPushRuleNotificationViewModel by fragmentViewModel()
 
     abstract val prefKeyToPushRuleId: Map<String, String>
 
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
         super.onViewCreated(view, savedInstanceState)
         observeViewEvents()
-        viewModel.onEach(VectorSettingsPushRuleNotificationViewState::isLoading) { isLoading ->
+        viewModel.onEach(VectorSettingsPushRuleNotificationViewState::isLoading) { updateLoadingView(it) }
-            if (isLoading) {
+        viewModel.onEach(VectorSettingsPushRuleNotificationViewState::rulesOnError) { refreshErrors(it) }
-                displayLoadingView()
-            } else {
-                hideLoadingView()
-            }
-        }
     }
 
     private fun observeViewEvents() {
         viewModel.observeViewEvents {
             when (it) {
-                is VectorSettingsPushRuleNotificationViewEvent.Failure -> refreshDisplay()
+                is VectorSettingsPushRuleNotificationViewEvent.Failure -> onFailure(it.ruleId)
-                is VectorSettingsPushRuleNotificationViewEvent.PushRuleUpdated -> updatePreference(it.ruleId, it.checked)
+                is VectorSettingsPushRuleNotificationViewEvent.PushRuleUpdated -> {
+                    updatePreference(it.ruleId, it.checked)
+                    if (it.failure != null) {
+                        onFailure(it.ruleId)
+                    }
+                }
             }
         }
     }
@@ -71,14 +73,28 @@ abstract class VectorSettingsPushRuleNotificationFragment :
         }
     }
 
-    override fun invalidate() = withState(viewModel) { state ->
+    private fun updateLoadingView(isLoading: Boolean) {
-        if (state.isLoading) {
+        if (isLoading) {
             displayLoadingView()
         } else {
             hideLoadingView()
         }
     }
 
+    private fun refreshErrors(rulesWithError: Set<String>) {
+        if (withState(viewModel, VectorSettingsPushRuleNotificationViewState::isLoading)) return
+        prefKeyToPushRuleId.forEach { (preferenceKey, ruleId) ->
+            val preference = findPreference<VectorCheckboxPreference>(preferenceKey)!!
+            if (ruleId in rulesWithError) {
+                preference.summaryTextColor = context?.let { ThemeUtils.getColor(it, R.attr.colorError) }
+                preference.setSummary(R.string.settings_notification_error_on_update)
+            } else {
+                preference.summaryTextColor = null
+                preference.summary = null
+            }
+        }
+    }
+
     protected fun refreshDisplay() {
         listView?.adapter?.notifyDataSetChanged()
     }
@@ -88,4 +104,8 @@ abstract class VectorSettingsPushRuleNotificationFragment :
         val preference = findPreference<VectorCheckboxPreference>(preferenceKey) ?: return
         preference.isChecked = checked
     }
+
+    protected open fun onFailure(ruleId: String) {
+        refreshDisplay()
+    }
 }

vector/src/main/java/im/vector/app/features/settings/notifications/VectorSettingsPushRuleNotificationViewEvent.kt

@@ -33,5 +33,5 @@ sealed interface VectorSettingsPushRuleNotificationViewEvent : VectorViewEvents
      *
      * @property throwable the related exception, if any.
      */
-    data class Failure(val throwable: Throwable?) : VectorSettingsPushRuleNotificationViewEvent
+    data class Failure(val ruleId: String, val throwable: Throwable?) : VectorSettingsPushRuleNotificationViewEvent
 }

vector/src/main/java/im/vector/app/features/settings/notifications/VectorSettingsPushRuleNotificationViewModel.kt

@@ -26,13 +26,17 @@ import im.vector.app.core.di.hiltMavericksViewModelFactory
 import im.vector.app.core.platform.VectorViewModel
 import im.vector.app.features.settings.notifications.VectorSettingsPushRuleNotificationViewEvent.Failure
 import im.vector.app.features.settings.notifications.VectorSettingsPushRuleNotificationViewEvent.PushRuleUpdated
+import im.vector.app.features.settings.notifications.usecase.GetPushRulesOnInvalidStateUseCase
 import kotlinx.coroutines.launch
 import org.matrix.android.sdk.api.failure.Failure.ServerError
 import org.matrix.android.sdk.api.failure.MatrixError
+import org.matrix.android.sdk.api.session.accountdata.UserAccountDataTypes
 import org.matrix.android.sdk.api.session.pushrules.Action
 import org.matrix.android.sdk.api.session.pushrules.RuleIds
 import org.matrix.android.sdk.api.session.pushrules.RuleKind
 import org.matrix.android.sdk.api.session.pushrules.rest.PushRuleAndKind
+import org.matrix.android.sdk.flow.flow
+import org.matrix.android.sdk.flow.unwrap
 
 private typealias ViewModel = VectorSettingsPushRuleNotificationViewModel
 private typealias ViewState = VectorSettingsPushRuleNotificationViewState
@@ -40,6 +44,7 @@ private typealias ViewState = VectorSettingsPushRuleNotificationViewState
 class VectorSettingsPushRuleNotificationViewModel @AssistedInject constructor(
         @Assisted initialState: ViewState,
         private val activeSessionHolder: ActiveSessionHolder,
+        private val getPushRulesOnInvalidStateUseCase: GetPushRulesOnInvalidStateUseCase,
 ) : VectorViewModel<VectorSettingsPushRuleNotificationViewState,
         VectorSettingsPushRuleNotificationViewAction,
         VectorSettingsPushRuleNotificationViewEvent>(initialState) {
@@ -51,6 +56,17 @@ class VectorSettingsPushRuleNotificationViewModel @AssistedInject constructor(
 
     companion object : MavericksViewModelFactory<ViewModel, ViewState> by hiltMavericksViewModelFactory()
 
+    init {
+        val session = activeSessionHolder.getSafeActiveSession()
+        session?.flow()
+                ?.liveUserAccountData(UserAccountDataTypes.TYPE_PUSH_RULES)
+                ?.unwrap()
+                ?.setOnEach {
+                    val rulesOnError = getPushRulesOnInvalidStateUseCase.execute(session).map { it.ruleId }.toSet()
+                    copy(rulesOnError = rulesOnError)
+                }
+    }
+
     override fun handle(action: VectorSettingsPushRuleNotificationViewAction) {
         when (action) {
             is VectorSettingsPushRuleNotificationViewAction.UpdatePushRule -> handleUpdatePushRule(action.pushRuleAndKind, action.checked)
@@ -73,6 +89,7 @@ class VectorSettingsPushRuleNotificationViewModel @AssistedInject constructor(
         val standardAction = getStandardAction(ruleId, newIndex) ?: return
         val enabled = standardAction != StandardActions.Disabled
         val newActions = standardAction.actions
+
         setState { copy(isLoading = true) }
 
         viewModelScope.launch {
@@ -82,22 +99,31 @@ class VectorSettingsPushRuleNotificationViewModel @AssistedInject constructor(
                     updatePushRule(kind, ruleId, enabled, newActions)
                 }
             }
-            setState { copy(isLoading = false) }
+
-            val failure = results.firstNotNullOfOrNull { result ->
+            val failures = results.mapNotNull { result ->
                 // If the failure is a rule not found error, do not consider it
                 result.exceptionOrNull()?.takeUnless { it is ServerError && it.error.code == MatrixError.M_NOT_FOUND }
             }
-            val newChecked = if (checked) {
+            val hasSuccess = results.any { it.isSuccess }
-                // If any rule is checked, the global rule is checked
+            val hasFailures = failures.isNotEmpty()
-                results.any { it.isSuccess }
+
+            // Any rule has been checked or some rules have not been unchecked
+            val newChecked = (checked && hasSuccess) || (!checked && hasFailures)
+            if (hasSuccess) {
+                _viewEvents.post(PushRuleUpdated(ruleId, newChecked, failures.firstOrNull()))
             } else {
-                // If any rule has not been unchecked, the global rule remains checked
+                _viewEvents.post(Failure(ruleId, failures.firstOrNull()))
-                failure != null
             }
-            if (results.any { it.isSuccess }) {
+
-                _viewEvents.post(PushRuleUpdated(ruleId, newChecked, failure))
+            setState {
-            } else {
+                copy(
-                _viewEvents.post(Failure(failure))
+                        isLoading = false,
+                        rulesOnError = when {
+                            hasSuccess && hasFailures -> rulesOnError.plus(ruleId) // some failed
+                            hasSuccess -> rulesOnError.minus(ruleId) // all succeed
+                            else -> rulesOnError // all failed
+                        }
+                )
             }
         }
     }

vector/src/main/java/im/vector/app/features/settings/notifications/VectorSettingsPushRuleNotificationViewState.kt

@@ -20,4 +20,5 @@ import com.airbnb.mvrx.MavericksState
 
 data class VectorSettingsPushRuleNotificationViewState(
         val isLoading: Boolean = false,
+        val rulesOnError: Set<String> = emptySet()
 ) : MavericksState

vector/src/main/java/im/vector/app/features/settings/notifications/usecase/GetPushRulesOnInvalidStateUseCase.kt

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * 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 im.vector.app.features.settings.notifications.usecase
+
+import org.matrix.android.sdk.api.extensions.orTrue
+import org.matrix.android.sdk.api.session.Session
+import org.matrix.android.sdk.api.session.pushrules.RuleIds
+import org.matrix.android.sdk.api.session.pushrules.getActions
+import org.matrix.android.sdk.api.session.pushrules.getParentRule
+import org.matrix.android.sdk.api.session.pushrules.getSyncedRules
+import org.matrix.android.sdk.api.session.pushrules.rest.PushRule
+import javax.inject.Inject
+
+class GetPushRulesOnInvalidStateUseCase @Inject constructor() {
+
+    fun execute(session: Session): List<PushRule> {
+        val allRules = session.pushRuleService().getPushRules().getAllRules()
+        return allRules.filter { it.isOnInvalidState(allRules) }
+    }
+
+    private fun PushRule.isOnInvalidState(allRules: List<PushRule>): Boolean {
+        val parent = RuleIds.getParentRule(ruleId)?.let { parentId -> allRules.find { it.ruleId == parentId } }
+        val children = RuleIds.getSyncedRules(ruleId).mapNotNull { childId -> allRules.find { it.ruleId == childId } }
+        val isAlignedWithParent = parent?.let { isAlignedWithParentRule(it) }.orTrue()
+        return !isAlignedWithParent || !isAlignedWithChildrenRules(children)
+    }
+
+    private fun PushRule.isAlignedWithParentRule(parent: PushRule) = this.getActions() == parent.getActions() && this.enabled == parent.enabled
+    private fun PushRule.isAlignedWithChildrenRules(children: List<PushRule>) = children.all { it.isAlignedWithParentRule(this) }
+}

vector/src/main/java/im/vector/app/features/settings/notifications/usecase/UpdatePushRulesIfNeededUseCase.kt

@@ -24,18 +24,18 @@ import org.matrix.android.sdk.api.session.pushrules.rest.PushRule
 import org.matrix.android.sdk.api.session.pushrules.rest.PushRuleAndKind
 import javax.inject.Inject
 
-class UpdatePushRulesIfNeededUseCase @Inject constructor() {
+class UpdatePushRulesIfNeededUseCase @Inject constructor(
+        private val getPushRulesOnInvalidStateUseCase: GetPushRulesOnInvalidStateUseCase,
+) {
 
     suspend fun execute(session: Session) {
+        val rulesOnError = getPushRulesOnInvalidStateUseCase.execute(session).takeUnless { it.isEmpty() } ?: return
+
         val ruleSet = session.pushRuleService().getPushRules()
-        val pushRules = ruleSet.getAllRules()
+        val rulesToUpdate = rulesOnError.mapNotNull { rule ->
-        val rulesToUpdate = pushRules.mapNotNull { rule ->
+            RuleIds.getParentRule(rule.ruleId)
-            val parent = RuleIds.getParentRule(rule.ruleId)?.let { ruleId -> ruleSet.findDefaultRule(ruleId) }
+                    ?.let { ruleId -> ruleSet.findDefaultRule(ruleId) }
-            if (parent != null && (rule.enabled != parent.pushRule.enabled || rule.actions != parent.pushRule.actions)) {
+                    ?.let { PushRuleWithParent(rule, it) }
-                PushRuleWithParent(rule, parent)
-            } else {
-                null
-            }
         }
 
         rulesToUpdate.forEach {

vector/src/main/res/xml/vector_settings_notification_default.xml

@@ -25,4 +25,4 @@
             android:title="@string/settings_encrypted_group_messages" />
 
     </im.vector.app.core.preference.VectorPreferenceCategory>
-</androidx.preference.PreferenceScreen>
+</androidx.preference.PreferenceScreen>

vector/src/test/java/im/vector/app/features/settings/notifications/VectorSettingsPushRuleNotificationViewModelTest.kt

@@ -17,7 +17,9 @@
 package im.vector.app.features.settings.notifications
 
 import com.airbnb.mvrx.test.MavericksTestRule
+import im.vector.app.features.settings.notifications.usecase.GetPushRulesOnInvalidStateUseCase
 import im.vector.app.test.fakes.FakeActiveSessionHolder
+import im.vector.app.test.fixtures.PushRuleFixture
 import im.vector.app.test.test
 import im.vector.app.test.testDispatcher
 import io.mockk.coVerifyOrder
@@ -41,16 +43,19 @@ internal class VectorSettingsPushRuleNotificationViewModelTest {
 
     private val fakeActiveSessionHolder = FakeActiveSessionHolder()
     private val fakePushRuleService = fakeActiveSessionHolder.fakeSession.fakePushRuleService
+    private val fakeGetPushRulesOnInvalidStateUseCase = mockk<GetPushRulesOnInvalidStateUseCase>()
 
     private val initialState = VectorSettingsPushRuleNotificationViewState()
     private fun createViewModel() = VectorSettingsPushRuleNotificationViewModel(
             initialState = initialState,
             activeSessionHolder = fakeActiveSessionHolder.instance,
+            fakeGetPushRulesOnInvalidStateUseCase,
     )
 
     @Before
     fun setup() {
         mockkStatic("im.vector.app.features.settings.notifications.NotificationIndexKt")
+        every { fakeGetPushRulesOnInvalidStateUseCase.execute(any()) } returns emptyList()
     }
 
     @After
@@ -98,8 +103,8 @@ internal class VectorSettingsPushRuleNotificationViewModelTest {
                         { copy(isLoading = false) },
                 )
                 .assertEvents(
-                        VectorSettingsPushRuleNotificationViewEvent.PushRuleUpdated(RuleIds.RULE_ID_ONE_TO_ONE_ROOM, true),
+                        VectorSettingsPushRuleNotificationViewEvent.PushRuleUpdated(firstRuleId, true),
-                        VectorSettingsPushRuleNotificationViewEvent.PushRuleUpdated(RuleIds.RULE_ID_ALL_OTHER_MESSAGES_ROOMS, false),
+                        VectorSettingsPushRuleNotificationViewEvent.PushRuleUpdated(secondRuleId, false),
                 )
                 .finish()
     }
@@ -149,13 +154,13 @@ internal class VectorSettingsPushRuleNotificationViewModelTest {
                 .assertStatesChanges(
                         initialState,
                         { copy(isLoading = true) },
-                        { copy(isLoading = false) },
+                        { copy(isLoading = false, setOf(firstRuleId)) },
                         { copy(isLoading = true) },
                         { copy(isLoading = false) },
                 )
                 .assertEvents(
-                        VectorSettingsPushRuleNotificationViewEvent.PushRuleUpdated(RuleIds.RULE_ID_ONE_TO_ONE_ROOM, true, failure),
+                        VectorSettingsPushRuleNotificationViewEvent.PushRuleUpdated(firstRuleId, true, failure),
-                        VectorSettingsPushRuleNotificationViewEvent.Failure(failure),
+                        VectorSettingsPushRuleNotificationViewEvent.Failure(secondRuleId, failure),
                 )
                 .finish()
     }
@@ -205,14 +210,14 @@ internal class VectorSettingsPushRuleNotificationViewModelTest {
                 .assertStatesChanges(
                         initialState,
                         { copy(isLoading = true) },
-                        { copy(isLoading = false) },
+                        { copy(isLoading = false, rulesOnError = setOf(firstRuleId)) },
                         { copy(isLoading = true) },
                         { copy(isLoading = false) },
                 )
                 .assertEvents(
                         // The global rule remains checked if all the rules are not unchecked
-                        VectorSettingsPushRuleNotificationViewEvent.PushRuleUpdated(RuleIds.RULE_ID_ONE_TO_ONE_ROOM, true, failure),
+                        VectorSettingsPushRuleNotificationViewEvent.PushRuleUpdated(firstRuleId, true, failure),
-                        VectorSettingsPushRuleNotificationViewEvent.Failure(failure),
+                        VectorSettingsPushRuleNotificationViewEvent.Failure(secondRuleId, failure),
                 )
                 .finish()
     }
@@ -245,11 +250,9 @@ internal class VectorSettingsPushRuleNotificationViewModelTest {
     }
 
     private fun givenARuleId(ruleId: String, notificationIndex: NotificationIndex = NotificationIndex.NOISY): PushRuleAndKind {
-        val ruleAndKind = mockk<PushRuleAndKind> {
+        val pushRule = PushRuleFixture.aPushRule(ruleId)
-            every { pushRule.ruleId } returns ruleId
+        every { pushRule.notificationIndex } returns notificationIndex
-            every { pushRule.notificationIndex } returns notificationIndex
+        val ruleAndKind = PushRuleFixture.aPushRuleAndKind(pushRule)
-            every { kind } returns mockk()
-        }
 
         every { fakePushRuleService.getPushRules().findDefaultRule(ruleId) } returns ruleAndKind
 

vector/src/test/java/im/vector/app/features/settings/notifications/usecase/GetPushRulesOnInvalidStateUseCaseTest.kt

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * 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 im.vector.app.features.settings.notifications.usecase
+
+import im.vector.app.test.fakes.FakeSession
+import im.vector.app.test.fixtures.PushRuleFixture
+import io.mockk.every
+import io.mockk.mockkStatic
+import io.mockk.unmockkAll
+import org.amshove.kluent.shouldBeEqualTo
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.matrix.android.sdk.api.session.pushrules.Action
+import org.matrix.android.sdk.api.session.pushrules.RuleIds
+import org.matrix.android.sdk.api.session.pushrules.rest.PushRule
+
+internal class GetPushRulesOnInvalidStateUseCaseTest {
+
+    private val fakeSession = FakeSession()
+    private val getPushRulesOnInvalidStateUseCase = GetPushRulesOnInvalidStateUseCase()
+
+    @Before
+    fun setup() {
+        mockkStatic("org.matrix.android.sdk.api.session.pushrules.ActionKt")
+    }
+
+    @After
+    fun tearDown() {
+        unmockkAll()
+    }
+
+    @Test
+    fun `given a list of push rules with children not matching their parent when execute then returns the list of not matching rules`() {
+        // Given
+        val firstActions = listOf(Action.Notify)
+        val secondActions = listOf(Action.DoNotNotify)
+        givenARuleList(
+                listOf(
+                        // first set of related rules
+                        givenARuleId(RuleIds.RULE_ID_ONE_TO_ONE_ROOM, true, firstActions),
+                        givenARuleId(RuleIds.RULE_ID_POLL_START_ONE_TO_ONE, true, listOf(Action.DoNotNotify)), // diff
+                        givenARuleId(RuleIds.RULE_ID_POLL_START_ONE_TO_ONE_UNSTABLE, true, emptyList()), // diff
+                        givenARuleId(RuleIds.RULE_ID_POLL_END_ONE_TO_ONE, false, listOf(Action.Notify)), // diff
+                        givenARuleId(RuleIds.RULE_ID_POLL_END_ONE_TO_ONE_UNSTABLE, true, listOf(Action.Notify)),
+                        // second set of related rules
+                        givenARuleId(RuleIds.RULE_ID_ALL_OTHER_MESSAGES_ROOMS, false, secondActions),
+                        givenARuleId(RuleIds.RULE_ID_POLL_START, true, listOf(Action.Notify)), // diff
+                        givenARuleId(RuleIds.RULE_ID_POLL_START_UNSTABLE, false, listOf(Action.DoNotNotify)),
+                        givenARuleId(RuleIds.RULE_ID_POLL_END, false, listOf(Action.Notify)), // diff
+                        givenARuleId(RuleIds.RULE_ID_POLL_END_UNSTABLE, true, listOf()), // diff
+                        // Another rule
+                        givenARuleId(RuleIds.RULE_ID_CONTAIN_USER_NAME, true, listOf(Action.Notify)),
+                )
+        )
+
+        // When
+        val result = getPushRulesOnInvalidStateUseCase.execute(fakeSession).map { it.ruleId }
+
+        // Then
+        result shouldBeEqualTo listOf(
+                RuleIds.RULE_ID_ONE_TO_ONE_ROOM, // parent rule
+                RuleIds.RULE_ID_POLL_START_ONE_TO_ONE,
+                RuleIds.RULE_ID_POLL_START_ONE_TO_ONE_UNSTABLE,
+                RuleIds.RULE_ID_POLL_END_ONE_TO_ONE,
+                RuleIds.RULE_ID_ALL_OTHER_MESSAGES_ROOMS, // parent rule
+                RuleIds.RULE_ID_POLL_START,
+                RuleIds.RULE_ID_POLL_END,
+                RuleIds.RULE_ID_POLL_END_UNSTABLE,
+        )
+    }
+
+    private fun givenARuleList(rules: List<PushRule>) {
+        every { fakeSession.fakePushRuleService.getPushRules().getAllRules() } returns rules
+    }
+
+    private fun givenARuleId(ruleId: String, enabled: Boolean, actions: List<Action>): PushRule {
+        val ruleAndKind = PushRuleFixture.aPushRuleAndKind(
+                PushRuleFixture.aPushRule(ruleId, enabled, actions),
+        )
+
+        every { fakeSession.fakePushRuleService.getPushRules().findDefaultRule(ruleId) } returns ruleAndKind
+
+        return ruleAndKind.pushRule
+    }
+}

vector/src/test/java/im/vector/app/features/settings/notifications/usecase/UpdatePushRulesIfNeededUseCaseTest.kt

@@ -17,6 +17,7 @@
 package im.vector.app.features.settings.notifications.usecase
 
 import im.vector.app.test.fakes.FakeSession
+import im.vector.app.test.fixtures.PushRuleFixture
 import io.mockk.coVerifySequence
 import io.mockk.every
 import io.mockk.mockk
@@ -28,14 +29,13 @@ import org.junit.Before
 import org.junit.Test
 import org.matrix.android.sdk.api.session.pushrules.Action
 import org.matrix.android.sdk.api.session.pushrules.RuleIds
-import org.matrix.android.sdk.api.session.pushrules.getActions
 import org.matrix.android.sdk.api.session.pushrules.rest.PushRule
-import org.matrix.android.sdk.api.session.pushrules.rest.PushRuleAndKind
 
 internal class UpdatePushRulesIfNeededUseCaseTest {
 
     private val fakeSession = FakeSession()
-    private val updatePushRulesIfNeededUseCase = UpdatePushRulesIfNeededUseCase()
+    private val fakeGetPushRulesOnInvalidStateUseCase = mockk<GetPushRulesOnInvalidStateUseCase>()
+    private val updatePushRulesIfNeededUseCase = UpdatePushRulesIfNeededUseCase(fakeGetPushRulesOnInvalidStateUseCase)
 
     @Before
     fun setup() {
@@ -50,25 +50,26 @@ internal class UpdatePushRulesIfNeededUseCaseTest {
     @Test
     fun test() = runTest {
         // Given
-        val firstActions = listOf(Action.Notify)
+        val firstParentEnabled = true
-        val secondActions = listOf(Action.DoNotNotify)
+        val firstParentActions = listOf(Action.Notify)
-        val rules = listOf(
+        val firstParent = givenARuleId(RuleIds.RULE_ID_ONE_TO_ONE_ROOM, firstParentEnabled, firstParentActions)
+        val secondParentEnabled = false
+        val secondParentActions = listOf(Action.DoNotNotify)
+        val secondParent = givenARuleId(RuleIds.RULE_ID_ALL_OTHER_MESSAGES_ROOMS, secondParentEnabled, secondParentActions)
+        val rulesOnError = listOf(
                 // first set of related rules
-                givenARuleId(RuleIds.RULE_ID_ONE_TO_ONE_ROOM, true, firstActions),
+                firstParent,
                 givenARuleId(RuleIds.RULE_ID_POLL_START_ONE_TO_ONE, true, listOf(Action.DoNotNotify)), // diff
                 givenARuleId(RuleIds.RULE_ID_POLL_START_ONE_TO_ONE_UNSTABLE, true, emptyList()), // diff
                 givenARuleId(RuleIds.RULE_ID_POLL_END_ONE_TO_ONE, false, listOf(Action.Notify)), // diff
-                givenARuleId(RuleIds.RULE_ID_POLL_END_ONE_TO_ONE_UNSTABLE, true, listOf(Action.Notify)),
                 // second set of related rules
-                givenARuleId(RuleIds.RULE_ID_ALL_OTHER_MESSAGES_ROOMS, false, secondActions),
+                secondParent,
                 givenARuleId(RuleIds.RULE_ID_POLL_START, true, listOf(Action.Notify)), // diff
-                givenARuleId(RuleIds.RULE_ID_POLL_START_UNSTABLE, false, listOf(Action.DoNotNotify)),
                 givenARuleId(RuleIds.RULE_ID_POLL_END, false, listOf(Action.Notify)), // diff
                 givenARuleId(RuleIds.RULE_ID_POLL_END_UNSTABLE, true, listOf()), // diff
-                // Another rule
-                givenARuleId(RuleIds.RULE_ID_CONTAIN_USER_NAME, true, listOf(Action.Notify)),
         )
-        every { fakeSession.fakePushRuleService.getPushRules().getAllRules() } returns rules
+        every { fakeGetPushRulesOnInvalidStateUseCase.execute(fakeSession) } returns rulesOnError
+        every { fakeSession.fakePushRuleService.getPushRules().getAllRules() } returns rulesOnError
 
         // When
         updatePushRulesIfNeededUseCase.execute(fakeSession)
@@ -77,30 +78,23 @@ internal class UpdatePushRulesIfNeededUseCaseTest {
         coVerifySequence {
             fakeSession.fakePushRuleService.getPushRules()
             // first set
-            fakeSession.fakePushRuleService.updatePushRuleActions(any(), RuleIds.RULE_ID_POLL_START_ONE_TO_ONE, true, firstActions)
+            fakeSession.fakePushRuleService.updatePushRuleActions(any(), RuleIds.RULE_ID_POLL_START_ONE_TO_ONE, firstParentEnabled, firstParentActions)
-            fakeSession.fakePushRuleService.updatePushRuleActions(any(), RuleIds.RULE_ID_POLL_START_ONE_TO_ONE_UNSTABLE, true, firstActions)
+            fakeSession.fakePushRuleService.updatePushRuleActions(any(), RuleIds.RULE_ID_POLL_START_ONE_TO_ONE_UNSTABLE, firstParentEnabled, firstParentActions)
-            fakeSession.fakePushRuleService.updatePushRuleActions(any(), RuleIds.RULE_ID_POLL_END_ONE_TO_ONE, true, firstActions)
+            fakeSession.fakePushRuleService.updatePushRuleActions(any(), RuleIds.RULE_ID_POLL_END_ONE_TO_ONE, firstParentEnabled, firstParentActions)
             // second set
-            fakeSession.fakePushRuleService.updatePushRuleActions(any(), RuleIds.RULE_ID_POLL_START, false, secondActions)
+            fakeSession.fakePushRuleService.updatePushRuleActions(any(), RuleIds.RULE_ID_POLL_START, secondParentEnabled, secondParentActions)
-            fakeSession.fakePushRuleService.updatePushRuleActions(any(), RuleIds.RULE_ID_POLL_END, false, secondActions)
+            fakeSession.fakePushRuleService.updatePushRuleActions(any(), RuleIds.RULE_ID_POLL_END, secondParentEnabled, secondParentActions)
-            fakeSession.fakePushRuleService.updatePushRuleActions(any(), RuleIds.RULE_ID_POLL_END_UNSTABLE, false, secondActions)
+            fakeSession.fakePushRuleService.updatePushRuleActions(any(), RuleIds.RULE_ID_POLL_END_UNSTABLE, secondParentEnabled, secondParentActions)
         }
     }
 
     private fun givenARuleId(ruleId: String, enabled: Boolean, actions: List<Action>): PushRule {
-        val pushRule = mockk<PushRule> {
+        val ruleAndKind = PushRuleFixture.aPushRuleAndKind(
-            every { this@mockk.ruleId } returns ruleId
+                pushRule = PushRuleFixture.aPushRule(ruleId, enabled, actions),
-            every { this@mockk.enabled } returns enabled
+        )
-            every { this@mockk.actions } returns actions
-            every { getActions() } returns actions
-        }
-        val ruleAndKind = mockk<PushRuleAndKind> {
-            every { this@mockk.pushRule } returns pushRule
-            every { kind } returns mockk()
-        }
 
         every { fakeSession.fakePushRuleService.getPushRules().findDefaultRule(ruleId) } returns ruleAndKind
 
-        return pushRule
+        return ruleAndKind.pushRule
     }
 }

vector/src/test/java/im/vector/app/test/fixtures/PushRuleFixture.kt

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * 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 im.vector.app.test.fixtures
+
+import io.mockk.every
+import io.mockk.mockk
+import org.matrix.android.sdk.api.session.pushrules.Action
+import org.matrix.android.sdk.api.session.pushrules.RuleSetKey
+import org.matrix.android.sdk.api.session.pushrules.getActions
+import org.matrix.android.sdk.api.session.pushrules.rest.PushRule
+import org.matrix.android.sdk.api.session.pushrules.rest.PushRuleAndKind
+
+object PushRuleFixture {
+
+    private const val A_RULE_ID = "a-rule-id"
+
+    // Needs: mockkStatic("org.matrix.android.sdk.api.session.pushrules.ActionKt")
+    fun aPushRule(
+            ruleId: String = A_RULE_ID,
+            enabled: Boolean = true,
+            actions: List<Action> = listOf(Action.Notify),
+    ): PushRule = mockk {
+        every { this@mockk.ruleId } returns ruleId
+        every { this@mockk.enabled } returns enabled
+        every { getActions() } returns actions
+    }
+
+    fun aPushRuleAndKind(
+            pushRule: PushRule = aPushRule(),
+            kind: RuleSetKey = RuleSetKey.UNDERRIDE,
+    ): PushRuleAndKind = mockk {
+        every { this@mockk.pushRule } returns pushRule
+        every { this@mockk.kind } returns kind
+    }
+}