Refresh DataUsageSummaryPreferenceController

When re-enter the page contains it.

Fix: 341234382
Test: manual - on Data usage
Test: unit test
Change-Id: Ib6a4624e11b60d703c35cea07232cc24f1516389

tests/spa_unit/src/com/android/settings/datausage/DataUsageSummaryPreferenceControllerTest.kt

@@ -32,8 +32,10 @@ import com.android.settings.core.BasePreferenceController.CONDITIONALLY_UNAVAILA
 import com.android.settings.datausage.lib.INetworkCycleDataRepository
 import com.android.settings.datausage.lib.NetworkUsageData
 import com.android.settings.network.ProxySubscriptionManager
+import com.android.settings.network.policy.NetworkPolicyRepository
 import com.google.common.truth.Truth.assertThat
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.runBlocking
 import org.junit.Before
 import org.junit.Test
@@ -41,6 +43,7 @@ import org.junit.runner.RunWith
 import org.mockito.kotlin.any
 import org.mockito.kotlin.argumentCaptor
 import org.mockito.kotlin.clearInvocations
+import org.mockito.kotlin.doAnswer
 import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.never
@@ -69,6 +72,10 @@ class DataUsageSummaryPreferenceControllerTest {
         on { get() } doReturn mockSubscriptionManager
     }
 
+    private val mockNetworkPolicyRepository = mock<NetworkPolicyRepository> {
+        on { networkPolicyFlow(any()) } doAnswer { flowOf(policy) }
+    }
+
     private val fakeNetworkCycleDataRepository = object : INetworkCycleDataRepository {
         override fun getCycles(): List<Range<Long>> = emptyList()
         override fun getPolicy() = policy
@@ -86,6 +93,7 @@ class DataUsageSummaryPreferenceControllerTest {
         context = context,
         subId = SUB_ID,
         proxySubscriptionManager = mockProxySubscriptionManager,
+        networkPolicyRepository = mockNetworkPolicyRepository,
         networkCycleDataRepositoryFactory = { fakeNetworkCycleDataRepository },
         dataPlanRepositoryFactory = { fakeDataPlanRepository },
     )
@@ -112,7 +120,7 @@ class DataUsageSummaryPreferenceControllerTest {
     }
 
     @Test
-    fun getAvailabilityStatus_hasSubInfoAndPolicy_available() {
+    fun getAvailabilityStatus_hasSubInfo_available() {
         mockProxySubscriptionManager.stub {
             on { getAccessibleSubscriptionInfo(SUB_ID) } doReturn SubscriptionInfo.Builder().build()
         }
@@ -134,36 +142,43 @@ class DataUsageSummaryPreferenceControllerTest {
     }
 
     @Test
-    fun getAvailabilityStatus_noPolicy_conditionallyUnavailable() {
+    fun onViewCreated_noPolicy_setInvisible() = runBlocking {
         policy = null
+        controller.displayPreference(preferenceScreen)
+        clearInvocations(preference)
 
-        val availabilityStatus = controller.getAvailabilityStatus(SUB_ID)
+        controller.onViewCreated(TestLifecycleOwner())
+        delay(100)
 
-        assertThat(availabilityStatus).isEqualTo(CONDITIONALLY_UNAVAILABLE)
+        verify(preference).isVisible = false
     }
 
     @Test
-    fun displayPreference_policyHasNoLimitInfo() {
+    fun onViewCreated_policyHasNoLimitInfo() = runBlocking {
         policy = mock<NetworkPolicy>().apply {
             warningBytes = NetworkPolicy.WARNING_DISABLED
             limitBytes = NetworkPolicy.LIMIT_DISABLED
         }
-
         controller.displayPreference(preferenceScreen)
 
+        controller.onViewCreated(TestLifecycleOwner())
+        delay(100)
+
         verify(preference).setLimitInfo(null)
         verify(preference, never()).setLabels(any(), any())
     }
 
     @Test
-    fun displayPreference_policyWarningOnly() {
+    fun onViewCreated_policyWarningOnly() = runBlocking {
         policy = mock<NetworkPolicy>().apply {
             warningBytes = 1L
             limitBytes = NetworkPolicy.LIMIT_DISABLED
         }
-
         controller.displayPreference(preferenceScreen)
 
+        controller.onViewCreated(TestLifecycleOwner())
+        delay(100)
+
         val limitInfo = argumentCaptor {
             verify(preference).setLimitInfo(capture())
         }.firstValue.toString()
@@ -172,14 +187,16 @@ class DataUsageSummaryPreferenceControllerTest {
     }
 
     @Test
-    fun displayPreference_policyLimitOnly() {
+    fun onViewCreated_policyLimitOnly() = runBlocking {
         policy = mock<NetworkPolicy>().apply {
             warningBytes = NetworkPolicy.WARNING_DISABLED
             limitBytes = 1L
         }
-
         controller.displayPreference(preferenceScreen)
 
+        controller.onViewCreated(TestLifecycleOwner())
+        delay(100)
+
         val limitInfo = argumentCaptor {
             verify(preference).setLimitInfo(capture())
         }.firstValue.toString()
@@ -188,14 +205,16 @@ class DataUsageSummaryPreferenceControllerTest {
     }
 
     @Test
-    fun displayPreference_policyHasWarningAndLimit() {
+    fun onViewCreated_policyHasWarningAndLimit() = runBlocking {
         policy = mock<NetworkPolicy>().apply {
             warningBytes = BillingCycleSettings.GIB_IN_BYTES / 2
             limitBytes = BillingCycleSettings.GIB_IN_BYTES
         }
-
         controller.displayPreference(preferenceScreen)
 
+        controller.onViewCreated(TestLifecycleOwner())
+        delay(100)
+
         val limitInfo = argumentCaptor {
             verify(preference).setLimitInfo(capture())
         }.firstValue.toString()
@@ -207,7 +226,6 @@ class DataUsageSummaryPreferenceControllerTest {
     fun onViewCreated_emptyDataPlanInfo() = runBlocking {
         dataPlanInfo = EMPTY_DATA_PLAN_INFO
         controller.displayPreference(preferenceScreen)
-        clearInvocations(preference)
 
         controller.onViewCreated(TestLifecycleOwner())
         delay(100)
@@ -229,7 +247,6 @@ class DataUsageSummaryPreferenceControllerTest {
     fun onViewCreated_positiveDataPlanInfo() = runBlocking {
         dataPlanInfo = POSITIVE_DATA_PLAN_INFO
         controller.displayPreference(preferenceScreen)
-        clearInvocations(preference)
 
         controller.onViewCreated(TestLifecycleOwner())
         delay(100)

tests/spa_unit/src/com/android/settings/network/policy/NetworkPolicyRepositoryTest.kt

@@ -0,0 +1,72 @@
+/*
+ * 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.settings.network.policy
+
+import android.content.Context
+import android.net.NetworkPolicy
+import android.net.NetworkPolicyManager
+import android.net.NetworkTemplate
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.android.settingslib.spa.testutils.firstWithTimeoutOrNull
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.runBlocking
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.spy
+
+@RunWith(AndroidJUnit4::class)
+class NetworkPolicyRepositoryTest {
+
+    private val mockNetworkPolicyManager = mock<NetworkPolicyManager> {
+        on { networkPolicies } doReturn arrayOf(Policy1, Policy2)
+    }
+
+    private val context: Context = spy(ApplicationProvider.getApplicationContext()) {
+        on { getSystemService(NetworkPolicyManager::class.java) } doReturn mockNetworkPolicyManager
+    }
+
+    private val repository = NetworkPolicyRepository(context)
+
+    @Test
+    fun getNetworkPolicy() {
+        val networkPolicy = repository.getNetworkPolicy(Template1)
+
+        assertThat(networkPolicy).isSameInstanceAs(Policy1)
+    }
+
+    @Test
+    fun networkPolicyFlow() = runBlocking {
+        val networkPolicy = repository.networkPolicyFlow(Template2).firstWithTimeoutOrNull()
+
+        assertThat(networkPolicy).isSameInstanceAs(Policy2)
+    }
+
+    private companion object {
+        val Template1: NetworkTemplate =
+            NetworkTemplate.Builder(NetworkTemplate.MATCH_MOBILE).build()
+        val Template2: NetworkTemplate = NetworkTemplate.Builder(NetworkTemplate.MATCH_WIFI).build()
+        val Policy1 = mock<NetworkPolicy>().apply {
+            template = Template1
+        }
+        val Policy2 = mock<NetworkPolicy>().apply {
+            template = Template2
+        }
+    }
+}